home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 March / macformat-022.iso / Shareware City / Developers / src / out-of-phase-102-c / OutOfPhase 1.02 Source / OutOfPhase Folder / BuildInstrument.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-23  |  111.0 KB  |  3,613 lines  |  [TEXT/KAHL]
  1. /* BuildInstrument.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Out Of Phase:  Digital Music Synthesis on General Purpose Computers    */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #include "MiscInfo.h"
  26. #include "Audit.h"
  27. #include "Debug.h"
  28. #include "Definitions.h"
  29.  
  30. #include "BuildInstrument.h"
  31. #include "Memory.h"
  32. #include "TrashTracker.h"
  33. #include "CompilerScanner.h"
  34. #include "InstrumentStructure.h"
  35. #include "OscillatorSpecifier.h"
  36. #include "OscillatorListSpecifier.h"
  37. #include "LFOSpecifier.h"
  38. #include "LFOListSpecifier.h"
  39. #include "FixedPoint.h"
  40. #include "DataMunging.h"
  41. #include "Envelope.h"
  42. #include "SampleSelector.h"
  43. #include "ModulationSpecifier.h"
  44.  
  45.  
  46.  
  47.  
  48. #define OPAREN "("
  49. #define CPAREN ")"
  50.  
  51.  
  52.  
  53.  
  54. #define INSTRLIST_ONCEONLY_LOUDNESS (1L << 0)
  55.  
  56. #define INSTRLIST_REQUIRED_LOUDNESS (1L << 0)
  57. #define INSTRLIST_REQUIRED_OSCILLATOR (1L << 1)
  58. #define INSTRLIST_REQUIREDMASK (INSTRLIST_REQUIRED_LOUDNESS\
  59.                     | INSTRLIST_REQUIRED_OSCILLATOR)
  60.  
  61.  
  62. #define LFODEFINITION_ONCEONLY_FREQENVELOPE (1L << 0)
  63. #define LFODEFINITION_ONCEONLY_AMPENVELOPE (1L << 1)
  64. #define LFODEFINITION_ONCEONLY_OSCILLATORTYPE (1L << 2)
  65. #define LFODEFINITION_ONCEONLY_MODULATIONTYPE (1L << 3)
  66. #define LFODEFINITION_ONCEONLY_ADDINGMODE (1L << 4)
  67.  
  68. #define LFODEFINITION_REQUIRED_FREQENVELOPE (1L << 0)
  69. #define LFODEFINITION_REQUIRED_AMPENVELOPE (1L << 1)
  70. #define LFODEFINITION_REQUIREDMASK (LFODEFINITION_REQUIRED_FREQENVELOPE\
  71.                     | LFODEFINITION_REQUIRED_AMPENVELOPE)
  72.  
  73.  
  74. #define OSCILLATORDEFINITION_ONCEONLY_TYPE (1L << 0)
  75. #define OSCILLATORDEFINITION_ONCEONLY_SAMPLELIST (1L << 1)
  76. #define OSCILLATORDEFINITION_ONCEONLY_MODULATORS (1L << 2)
  77. #define OSCILLATORDEFINITION_ONCEONLY_LOUDNESS (1L << 3)
  78. #define OSCILLATORDEFINITION_ONCEONLY_FREQMULTIPLIER (1L << 4)
  79. #define OSCILLATORDEFINITION_ONCEONLY_FREQDIVISOR (1L << 5)
  80. #define OSCILLATORDEFINITION_ONCEONLY_MAKEOUTPUT (1L << 6)
  81. #define OSCILLATORDEFINITION_ONCEONLY_LOUDNESSENVELOPE (1L << 7)
  82. #define OSCILLATORDEFINITION_ONCEONLY_INDEXENVELOPE (1L << 8)
  83. #define OSCILLATORDEFINITION_ONCEONLY_STEREOBIAS (1L << 9)
  84. #define OSCILLATORDEFINITION_ONCEONLY_TIMEDISPLACEMENT (1L << 10)
  85. #define OSCILLATORDEFINITION_ONCEONLY_SURROUNDBIAS (1L << 11)
  86. #define OSCILLATORDEFINITION_ONCEONLY_FREQADDER (1L << 12)
  87.  
  88. #define OSCILLATORDEFINITION_REQUIRED_TYPE (1L << 0)
  89. #define OSCILLATORDEFINITION_REQUIRED_LOUDNESS (1L << 1)
  90. #define OSCILLATORDEFINITION_REQUIRED_LOUDNESSENVELOPE (1L << 2)
  91. #define OSCILLATORDEFINITION_REQUIRED_SAMPLELIST (1L << 3)
  92.  
  93. #define OSCILLATORDEFINITION_REQUIREDMASK (OSCILLATORDEFINITION_REQUIRED_TYPE\
  94.                     | OSCILLATORDEFINITION_REQUIRED_LOUDNESS\
  95.                     | OSCILLATORDEFINITION_REQUIRED_LOUDNESSENVELOPE\
  96.                     | OSCILLATORDEFINITION_REQUIRED_SAMPLELIST)
  97.  
  98.  
  99. #define ENVELOPEDEFINITION_ONCEONLY_TOTALSCALING (1L << 1)
  100. #define ENVELOPEDEFINITION_ONCEONLY_POINTS (1L << 2)
  101.  
  102. #define ENVELOPEDEFINITION_REQUIREDMASK (0L)
  103.  
  104.  
  105. #define ENVPOINTDEFINITION_ONCEONLY_AMPACCENT1 (1L << 0)
  106. #define ENVPOINTDEFINITION_ONCEONLY_AMPACCENT2 (1L << 1)
  107. #define ENVPOINTDEFINITION_ONCEONLY_AMPACCENT3 (1L << 2)
  108. #define ENVPOINTDEFINITION_ONCEONLY_AMPACCENT4 (1L << 3)
  109. #define ENVPOINTDEFINITION_ONCEONLY_AMPFREQ (1L << 4)
  110. #define ENVPOINTDEFINITION_ONCEONLY_RATEACCENT1 (1L << 5)
  111. #define ENVPOINTDEFINITION_ONCEONLY_RATEACCENT2 (1L << 6)
  112. #define ENVPOINTDEFINITION_ONCEONLY_RATEACCENT3 (1L << 7)
  113. #define ENVPOINTDEFINITION_ONCEONLY_RATEACCENT4 (1L << 8)
  114. #define ENVPOINTDEFINITION_ONCEONLY_RATEFREQ (1L << 9)
  115. #define ENVPOINTDEFINITION_ONCEONLY_CURVE (1L << 10)
  116.  
  117.  
  118.  
  119.  
  120. /* prototypes */
  121. static BuildInstrErrors            ParseInstrDefinition(InstrumentRec* Instrument,
  122.                                                             ScannerRec* Scanner, long* ErrorLine,
  123.                                                             struct SampleListRec* SampleList,
  124.                                                             struct AlgoSampListRec* AlgoSampList,
  125.                                                             struct WaveTableListRec* WaveTableList,
  126.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  127. static BuildInstrErrors            ParseInstrList(InstrumentRec* Instrument,
  128.                                                             ScannerRec* Scanner, long* ErrorLine,
  129.                                                             unsigned long* RequiredDefinitions,
  130.                                                             unsigned long OnceOnlyDefinitions,
  131.                                                             struct SampleListRec* SampleList,
  132.                                                             struct AlgoSampListRec* AlgoSampList,
  133.                                                             struct WaveTableListRec* WaveTableList,
  134.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  135. static BuildInstrErrors            ParseInstrElem(InstrumentRec* Instrument,
  136.                                                             ScannerRec* Scanner, long* ErrorLine,
  137.                                                             unsigned long* RequiredDefinitions,
  138.                                                             unsigned long* OnceOnlyDefinitions,
  139.                                                             struct SampleListRec* SampleList,
  140.                                                             struct AlgoSampListRec* AlgoSampList,
  141.                                                             struct WaveTableListRec* WaveTableList,
  142.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  143. static BuildInstrErrors            ParseNumber(ScannerRec* Scanner, long* ErrorLine,
  144.                                                             double* NumberOut);
  145. static BuildInstrErrors            ParseLfoDefinition(LFOSpecRec* LFO, ScannerRec* Scanner,
  146.                                                             long* ErrorLine, unsigned long* RequiredDefinitions,
  147.                                                             unsigned long OnceOnlyDefinitions,
  148.                                                             struct WaveTableListRec* WaveTableList,
  149.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  150. static BuildInstrErrors            ParseIdentifier(ScannerRec* Scanner, long* ErrorLine,
  151.                                                             char** IdentifierOut);
  152. static BuildInstrErrors            ParseOscillatorDefinition(OscillatorRec* Oscillator,
  153.                                                             ScannerRec* Scanner, long* ErrorLine,
  154.                                                             unsigned long* RequiredDefinitions,
  155.                                                             unsigned long OnceOnlyDefinitions,
  156.                                                             struct WaveTableListRec* WaveTableList,
  157.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  158. static BuildInstrErrors            ParseLfoElem(LFOSpecRec* LFO, ScannerRec* Scanner,
  159.                                                             long* ErrorLine, unsigned long* RequiredDefinitions,
  160.                                                             unsigned long* OnceOnlyDefinitions,
  161.                                                             struct WaveTableListRec* WaveTableList,
  162.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  163. static BuildInstrErrors            ParseOscillatorElem(OscillatorRec* Oscillator,
  164.                                                             ScannerRec* Scanner, long* ErrorLine,
  165.                                                             unsigned long* RequiredDefinitions,
  166.                                                             unsigned long* OnceOnlyDefinitions,
  167.                                                             struct WaveTableListRec* WaveTableList,
  168.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  169. static BuildInstrErrors            ParseEnvelopeDefinition(EnvelopeRec* Envelope,
  170.                                                             ScannerRec* Scanner, long* ErrorLine,
  171.                                                             unsigned long* RequiredDefinitions,
  172.                                                             unsigned long OnceOnlyDefinitions);
  173. static BuildInstrErrors            ParseSamplelistDefinition(SampleSelectorRec* SampleList,
  174.                                                             ScannerRec* Scanner, long* ErrorLine);
  175. static BuildInstrErrors            ParseModulatorList(ModulationSpecRec* ModulatorList,
  176.                                                             ScannerRec* Scanner, long* ErrorLine,
  177.                                                             struct WaveTableListRec* WaveTableList,
  178.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  179. static BuildInstrErrors            ParseEnvelopeElem(EnvelopeRec* Envelope,
  180.                                                             ScannerRec* Scanner, long *ErrorLine,
  181.                                                             unsigned long* RequiredDefinitions,
  182.                                                             unsigned long* OnceOnlyDefinitions);
  183. static BuildInstrErrors            ParseSamplelistElem(SampleSelectorRec* SampleList,
  184.                                                             ScannerRec* Scanner, long* ErrorLine);
  185. static BuildInstrErrors            ParseModulatorElem(ModulationSpecRec* ModulatorList,
  186.                                                             ScannerRec* Scanner, long* ErrorLine,
  187.                                                             struct WaveTableListRec* WaveTableList,
  188.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  189. static BuildInstrErrors            ParseEnvPointList(EnvelopeRec* Envelope,
  190.                                                             ScannerRec* Scanner, long *ErrorLine);
  191. static BuildInstrErrors            ParseEnvPointElem(EnvelopeRec* Envelope,
  192.                                                             ScannerRec* Scanner, long *ErrorLine);
  193. static BuildInstrErrors            ParseEnvAttributes(EnvelopeRec* Envelope,
  194.                                                             ScannerRec* Scanner, long *ErrorLine,
  195.                                                             unsigned long OnceOnly);
  196. static BuildInstrErrors            ParseEnvOneAttribute(EnvelopeRec* Envelope,
  197.                                                             ScannerRec* Scanner, long *ErrorLine,
  198.                                                             unsigned long* OnceOnlyDefinitions);
  199. static BuildInstrErrors            ParseModulationDynamic(LFOListSpecRec** LFOListOut,
  200.                                                             EnvelopeRec** EnvelopeOut, ScannerRec* Scanner,
  201.                                                             long* ErrorLine, struct WaveTableListRec* WaveTableList,
  202.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  203.  
  204.  
  205.  
  206.  
  207. /* token enumeration definitions */
  208. typedef enum
  209.     {
  210.         eKeywordInstrument EXECUTE(= -1274),
  211.         eKeywordLoudness,
  212.         eKeywordFrequencylfo,
  213.         eKeywordOscillator,
  214.         eKeywordFreqenvelope,
  215.         eKeywordModulation,
  216.         eKeywordConstant,
  217.         eKeywordSignsine,
  218.         eKeywordPlussine,
  219.         eKeywordSigntriangle,
  220.         eKeywordPlustriangle,
  221.         eKeywordSignsquare,
  222.         eKeywordPlussquare,
  223.         eKeywordSignramp,
  224.         eKeywordPlusramp,
  225.         eKeywordSignlinfuzz,
  226.         eKeywordPluslinfuzz,
  227.         eKeywordAdditive,
  228.         eKeywordMultiplicative,
  229.         eKeywordInversemult,
  230.         eKeywordType,
  231.         eKeywordSampled,
  232.         eKeywordWavetable,
  233.         eKeywordSamplelist,
  234.         eKeywordModulators,
  235.         eKeywordFreqmultiplier,
  236.         eKeywordFreqdivisor,
  237.         eKeywordFreqadder,
  238.         eKeywordMakeoutput,
  239.         eKeywordTrue,
  240.         eKeywordFalse,
  241.         eKeywordLoudnessenvelope,
  242.         eKeywordTotalscaling,
  243.         eKeywordExponential,
  244.         eKeywordLinear,
  245.         eKeywordLevel,
  246.         eKeywordDelay,
  247.         eKeywordSustainpoint,
  248.         eKeywordReleasepoint,
  249.         eKeywordSustainpointnoskip,
  250.         eKeywordReleasepointnoskip,
  251.         eKeywordAmpaccent1,
  252.         eKeywordAmpaccent2,
  253.         eKeywordAmpaccent3,
  254.         eKeywordAmpaccent4,
  255.         eKeywordAmpfreq,
  256.         eKeywordRateaccent1,
  257.         eKeywordRateaccent2,
  258.         eKeywordRateaccent3,
  259.         eKeywordRateaccent4,
  260.         eKeywordRatefreq,
  261.         eKeywordSource,
  262.         eKeywordScale,
  263.         eKeywordOriginadjust,
  264.         eKeywordPhasegen,
  265.         eKeywordOutput,
  266.         eKeywordAmpenvelope,
  267.         eKeywordLoudnesslfo,
  268.         eKeywordIndexenvelope,
  269.         eKeywordIndexlfo,
  270.         eKeywordPoints,
  271.         eKeywordTarget,
  272.         eKeywordOrigin,
  273.         eKeywordLfo,
  274.         eKeywordEnvelope,
  275.         eKeywordStereobias,
  276.         eKeywordDisplacement,
  277.         eKeywordSurroundbias
  278.     } KeywordType;
  279.  
  280.  
  281.  
  282.  
  283. /* take a block of text and parse it into an instrument definition.  it returns an */
  284. /* error code.  if an error occurs, then *InstrOut is invalid, otherwise it will */
  285. /* be valid.  the text file remains unaltered.  *ErrorLine is numbered from 1. */
  286. BuildInstrErrors                        BuildInstrumentFromText(char* TextFile, long* ErrorLine,
  287.                                                             struct InstrumentRec** InstrOut,
  288.                                                             struct SampleListRec* SampleList,
  289.                                                             struct AlgoSampListRec* AlgoSampList,
  290.                                                             struct WaveTableListRec* WaveTableList,
  291.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  292.     {
  293.         TrashTrackRec*                        TrashTracker;
  294.         ScannerRec*                                Scanner;
  295.         InstrumentRec*                        Instrument;
  296.         BuildInstrErrors                    Error;
  297.         TokenRec*                                    Token;
  298.  
  299.         CheckPtrExistence(TextFile);
  300.         CheckPtrExistence(SampleList);
  301.         CheckPtrExistence(AlgoSampList);
  302.         CheckPtrExistence(WaveTableList);
  303.         CheckPtrExistence(AlgoWaveTableList);
  304.         EXECUTE(*InstrOut = (InstrumentRec*)0x81818181;)
  305.         EXECUTE(*ErrorLine = 0x81818181;)
  306.  
  307.         TrashTracker = NewTrashTracker();
  308.         if (TrashTracker == NIL)
  309.             {
  310.              NoMemoryFailurePoint1:
  311.                 *ErrorLine = 1;
  312.                 return eBuildInstrOutOfMemory;
  313.             }
  314.  
  315.         Scanner = NewScanner(TrashTracker,TextFile);
  316.         if (Scanner == NIL)
  317.             {
  318.              NoMemoryFailurePoint2:
  319.                 goto NoMemoryFailurePoint1;
  320.             }
  321.  
  322.         Instrument = NewInstrumentSpecifier();
  323.         if (Instrument == NIL)
  324.             {
  325.              NoMemoryFailurePoint3:
  326.                 goto NoMemoryFailurePoint2;
  327.             }
  328.  
  329.         AddKeywordToScanner(Scanner,"instrument",eKeywordInstrument);
  330.         AddKeywordToScanner(Scanner,"loudness",eKeywordLoudness);
  331.         AddKeywordToScanner(Scanner,"frequencylfo",eKeywordFrequencylfo);
  332.         AddKeywordToScanner(Scanner,"oscillator",eKeywordOscillator);
  333.         AddKeywordToScanner(Scanner,"freqenvelope",eKeywordFreqenvelope);
  334.         AddKeywordToScanner(Scanner,"modulation",eKeywordModulation);
  335.         AddKeywordToScanner(Scanner,"constant",eKeywordConstant);
  336.         AddKeywordToScanner(Scanner,"signsine",eKeywordSignsine);
  337.         AddKeywordToScanner(Scanner,"plussine",eKeywordPlussine);
  338.         AddKeywordToScanner(Scanner,"signtriangle",eKeywordSigntriangle);
  339.         AddKeywordToScanner(Scanner,"plustriangle",eKeywordPlustriangle);
  340.         AddKeywordToScanner(Scanner,"signsquare",eKeywordSignsquare);
  341.         AddKeywordToScanner(Scanner,"plussquare",eKeywordPlussquare);
  342.         AddKeywordToScanner(Scanner,"signramp",eKeywordSignramp);
  343.         AddKeywordToScanner(Scanner,"plusramp",eKeywordPlusramp);
  344.         AddKeywordToScanner(Scanner,"signlinfuzz",eKeywordSignlinfuzz);
  345.         AddKeywordToScanner(Scanner,"pluslinfuzz",eKeywordPluslinfuzz);
  346.         AddKeywordToScanner(Scanner,"additive",eKeywordAdditive);
  347.         AddKeywordToScanner(Scanner,"multiplicative",eKeywordMultiplicative);
  348.         AddKeywordToScanner(Scanner,"inversemult",eKeywordInversemult);
  349.         AddKeywordToScanner(Scanner,"type",eKeywordType);
  350.         AddKeywordToScanner(Scanner,"sampled",eKeywordSampled);
  351.         AddKeywordToScanner(Scanner,"wavetable",eKeywordWavetable);
  352.         AddKeywordToScanner(Scanner,"samplelist",eKeywordSamplelist);
  353.         AddKeywordToScanner(Scanner,"modulators",eKeywordModulators);
  354.         AddKeywordToScanner(Scanner,"freqmultiplier",eKeywordFreqmultiplier);
  355.         AddKeywordToScanner(Scanner,"freqdivisor",eKeywordFreqdivisor);
  356.         AddKeywordToScanner(Scanner,"freqadder",eKeywordFreqadder);
  357.         AddKeywordToScanner(Scanner,"makeoutput",eKeywordMakeoutput);
  358.         AddKeywordToScanner(Scanner,"true",eKeywordTrue);
  359.         AddKeywordToScanner(Scanner,"false",eKeywordFalse);
  360.         AddKeywordToScanner(Scanner,"loudnessenvelope",eKeywordLoudnessenvelope);
  361.         AddKeywordToScanner(Scanner,"totalscaling",eKeywordTotalscaling);
  362.         AddKeywordToScanner(Scanner,"exponential",eKeywordExponential);
  363.         AddKeywordToScanner(Scanner,"linear",eKeywordLinear);
  364.         AddKeywordToScanner(Scanner,"level",eKeywordLevel);
  365.         AddKeywordToScanner(Scanner,"delay",eKeywordDelay);
  366.         AddKeywordToScanner(Scanner,"sustainpoint",eKeywordSustainpoint);
  367.         AddKeywordToScanner(Scanner,"releasepoint",eKeywordReleasepoint);
  368.         AddKeywordToScanner(Scanner,"sustainpointnoskip",eKeywordSustainpointnoskip);
  369.         AddKeywordToScanner(Scanner,"releasepointnoskip",eKeywordReleasepointnoskip);
  370.         AddKeywordToScanner(Scanner,"ampaccent1",eKeywordAmpaccent1);
  371.         AddKeywordToScanner(Scanner,"ampaccent2",eKeywordAmpaccent2);
  372.         AddKeywordToScanner(Scanner,"ampaccent3",eKeywordAmpaccent3);
  373.         AddKeywordToScanner(Scanner,"ampaccent4",eKeywordAmpaccent4);
  374.         AddKeywordToScanner(Scanner,"ampfreq",eKeywordAmpfreq);
  375.         AddKeywordToScanner(Scanner,"rateaccent1",eKeywordRateaccent1);
  376.         AddKeywordToScanner(Scanner,"rateaccent2",eKeywordRateaccent2);
  377.         AddKeywordToScanner(Scanner,"rateaccent3",eKeywordRateaccent3);
  378.         AddKeywordToScanner(Scanner,"rateaccent4",eKeywordRateaccent4);
  379.         AddKeywordToScanner(Scanner,"ratefreq",eKeywordRatefreq);
  380.         AddKeywordToScanner(Scanner,"source",eKeywordSource);
  381.         AddKeywordToScanner(Scanner,"scale",eKeywordScale);
  382.         AddKeywordToScanner(Scanner,"originadjust",eKeywordOriginadjust);
  383.         AddKeywordToScanner(Scanner,"phasegen",eKeywordPhasegen);
  384.         AddKeywordToScanner(Scanner,"output",eKeywordOutput);
  385.         AddKeywordToScanner(Scanner,"ampenvelope",eKeywordAmpenvelope);
  386.         AddKeywordToScanner(Scanner,"loudnesslfo",eKeywordLoudnesslfo);
  387.         AddKeywordToScanner(Scanner,"indexenvelope",eKeywordIndexenvelope);
  388.         AddKeywordToScanner(Scanner,"indexlfo",eKeywordIndexlfo);
  389.         AddKeywordToScanner(Scanner,"points",eKeywordPoints);
  390.         AddKeywordToScanner(Scanner,"target",eKeywordTarget);
  391.         AddKeywordToScanner(Scanner,"origin",eKeywordOrigin);
  392.         AddKeywordToScanner(Scanner,"lfo",eKeywordLfo);
  393.         AddKeywordToScanner(Scanner,"envelope",eKeywordEnvelope);
  394.         AddKeywordToScanner(Scanner,"stereobias",eKeywordStereobias);
  395.         AddKeywordToScanner(Scanner,"displacement",eKeywordDisplacement);
  396.         AddKeywordToScanner(Scanner,"surroundbias",eKeywordSurroundbias);
  397.  
  398.         Error = ParseInstrDefinition(Instrument,Scanner,ErrorLine,SampleList,AlgoSampList,
  399.             WaveTableList,AlgoWaveTableList);
  400.         if (Error != eBuildInstrNoError)
  401.             {
  402.                 DisposeInstrumentSpecification(Instrument);
  403.                 DisposeTrashTracker(TrashTracker);
  404.                 return Error;
  405.             }
  406.         if (!ResolveInstrOscillatorModulations(Instrument))
  407.             {
  408.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  409.                 DisposeInstrumentSpecification(Instrument);
  410.                 DisposeTrashTracker(TrashTracker);
  411.                 return eBuildInstrUnresolvedOscillatorReferences;
  412.             }
  413.  
  414.         Token = GetNextToken(Scanner);
  415.         if (Token == NIL)
  416.             {
  417.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  418.                 DisposeInstrumentSpecification(Instrument);
  419.                 DisposeTrashTracker(TrashTracker);
  420.                 return eBuildInstrOutOfMemory;
  421.             }
  422.         if (GetTokenType(Token) != eTokenEndOfInput)
  423.             {
  424.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  425.                 DisposeInstrumentSpecification(Instrument);
  426.                 DisposeTrashTracker(TrashTracker);
  427.                 return eBuildInstrUnexpectedInput;
  428.             }
  429.  
  430.         DisposeTrashTracker(TrashTracker);
  431.  
  432.         *InstrOut = Instrument;
  433.         return eBuildInstrNoError;
  434.     }
  435.  
  436.  
  437.  
  438.  
  439. /*    1:   <instr_definition>      ::= instrument ( <instr_list> ) */
  440. /* FIRST SET: */
  441. /*  <instr_definition>      : {instrument} */
  442. /* FOLLOW SET: */
  443. /*  <instr_definition>      : {$$$} */
  444. static BuildInstrErrors            ParseInstrDefinition(InstrumentRec* Instrument,
  445.                                                             ScannerRec* Scanner, long* ErrorLine,
  446.                                                             struct SampleListRec* SampleList,
  447.                                                             struct AlgoSampListRec* AlgoSampList,
  448.                                                             struct WaveTableListRec* WaveTableList,
  449.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  450.     {
  451.         TokenRec*                                    Token;
  452.         BuildInstrErrors                    Error;
  453.         unsigned long                            Required;
  454.  
  455.         CheckPtrExistence(Instrument);
  456.         CheckPtrExistence(Scanner);
  457.  
  458.         Token = GetNextToken(Scanner);
  459.         if (Token == NIL)
  460.             {
  461.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  462.                 return eBuildInstrOutOfMemory;
  463.             }
  464.         if ((GetTokenType(Token) != eTokenKeyword)
  465.             || (GetTokenKeywordTag(Token) != eKeywordInstrument))
  466.             {
  467.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  468.                 return eBuildInstrExpectedInstrument;
  469.             }
  470.  
  471.         Token = GetNextToken(Scanner);
  472.         if (Token == NIL)
  473.             {
  474.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  475.                 return eBuildInstrOutOfMemory;
  476.             }
  477.         if (GetTokenType(Token) != eTokenOpenParen)
  478.             {
  479.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  480.                 return eBuildInstrExpectedOpenParen;
  481.             }
  482.  
  483.         Required = 0;
  484.         Error = ParseInstrList(Instrument,Scanner,ErrorLine,&Required,0,SampleList,
  485.             AlgoSampList,WaveTableList,AlgoWaveTableList);
  486.         if (Error != eBuildInstrNoError)
  487.             {
  488.                 return Error;
  489.             }
  490.         if (Required != INSTRLIST_REQUIREDMASK)
  491.             {
  492.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  493.                 return eBuildInstrSomeRequiredInstrParamsMissing;
  494.             }
  495.  
  496.         Token = GetNextToken(Scanner);
  497.         if (Token == NIL)
  498.             {
  499.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  500.                 return eBuildInstrOutOfMemory;
  501.             }
  502.         if (GetTokenType(Token) != eTokenCloseParen)
  503.             {
  504.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  505.                 return eBuildInstrExpectedCloseParen;
  506.             }
  507.  
  508.         return eBuildInstrNoError;
  509.     }
  510.  
  511.  
  512.  
  513.  
  514. /*    2:   <instr_list>            ::= <instr_elem> ; <instr_list> */
  515. /*    3:                           ::=  */
  516. /* FIRST SET: */
  517. /*  <instr_list>            : {loudness, frequencylfo, oscillator, <instr_elem>} */
  518. /* FOLLOW SET: */
  519. /*  <instr_list>            : {)} */
  520. static BuildInstrErrors            ParseInstrList(InstrumentRec* Instrument,
  521.                                                             ScannerRec* Scanner, long* ErrorLine,
  522.                                                             unsigned long* RequiredDefinitions,
  523.                                                             unsigned long OnceOnlyDefinitions,
  524.                                                             struct SampleListRec* SampleList,
  525.                                                             struct AlgoSampListRec* AlgoSampList,
  526.                                                             struct WaveTableListRec* WaveTableList,
  527.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  528.     {
  529.         TokenRec*                                    Token;
  530.         BuildInstrErrors                    Error;
  531.  
  532.         CheckPtrExistence(Instrument);
  533.         CheckPtrExistence(Scanner);
  534.  
  535.         Token = GetNextToken(Scanner);
  536.         if (Token == NIL)
  537.             {
  538.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  539.                 return eBuildInstrOutOfMemory;
  540.             }
  541.  
  542.         if (GetTokenType(Token) == eTokenCloseParen)
  543.             {
  544.                 UngetToken(Scanner,Token);
  545.                 return eBuildInstrNoError;
  546.             }
  547.          else
  548.             {
  549.                 UngetToken(Scanner,Token);
  550.  
  551.                 Error = ParseInstrElem(Instrument,Scanner,ErrorLine,RequiredDefinitions,
  552.                     &OnceOnlyDefinitions,SampleList,AlgoSampList,WaveTableList,AlgoWaveTableList);
  553.                 if (Error != eBuildInstrNoError)
  554.                     {
  555.                         return Error;
  556.                     }
  557.  
  558.                 /* get semicolon */
  559.                 Token = GetNextToken(Scanner);
  560.                 if (Token == NIL)
  561.                     {
  562.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  563.                         return eBuildInstrOutOfMemory;
  564.                     }
  565.                 if (GetTokenType(Token) != eTokenSemicolon)
  566.                     {
  567.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  568.                         return eBuildInstrExpectedSemicolon;
  569.                     }
  570.  
  571.                 return ParseInstrList(Instrument,Scanner,ErrorLine,RequiredDefinitions,
  572.                     OnceOnlyDefinitions,SampleList,AlgoSampList,WaveTableList,AlgoWaveTableList);
  573.             }
  574.         EXECUTE(PRERR(ForceAbort,"ParseInstrList:  control reached end of function"));
  575.     }
  576.  
  577.  
  578.  
  579.  
  580. /*    4:   <instr_elem>            ::= loudness <number> */
  581. /*    5:                           ::= frequencylfo ( <lfo_definition> ) */
  582. /*    6:                           ::= oscillator <identifier> ( <oscillator_definition> ) */
  583. /* FIRST SET: */
  584. /*  <instr_elem>            : {loudness, frequencylfo, oscillator} */
  585. /* FOLLOW SET: */
  586. /*  <instr_elem>            : {;} */
  587. static BuildInstrErrors            ParseInstrElem(InstrumentRec* Instrument,
  588.                                                             ScannerRec* Scanner, long* ErrorLine,
  589.                                                             unsigned long* RequiredDefinitions,
  590.                                                             unsigned long* OnceOnlyDefinitions,
  591.                                                             struct SampleListRec* SampleList,
  592.                                                             struct AlgoSampListRec* AlgoSampList,
  593.                                                             struct WaveTableListRec* WaveTableList,
  594.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  595.     {
  596.         TokenRec*                                    Token;
  597.         BuildInstrErrors                    Error;
  598.  
  599.         CheckPtrExistence(Instrument);
  600.         CheckPtrExistence(Scanner);
  601.  
  602.         Token = GetNextToken(Scanner);
  603.         if (Token == NIL)
  604.             {
  605.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  606.                 return eBuildInstrOutOfMemory;
  607.             }
  608.         if (GetTokenType(Token) != eTokenKeyword)
  609.             {
  610.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  611.                 return eBuildInstrExpectedInstrumentMember;
  612.             }
  613.  
  614.         if (GetTokenKeywordTag(Token) == eKeywordLoudness)
  615.             {
  616.                 double                                        Number;
  617.  
  618.                 if ((*OnceOnlyDefinitions & INSTRLIST_ONCEONLY_LOUDNESS) != 0)
  619.                     {
  620.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  621.                         return eBuildInstrMultipleInstrLoudness;
  622.                     }
  623.                 Error = ParseNumber(Scanner,ErrorLine,&Number);
  624.                 if (Error != eBuildInstrNoError)
  625.                     {
  626.                         return Error;
  627.                     }
  628.                 InstrumentSetOverallLoudness(Instrument,Number);
  629.                 *OnceOnlyDefinitions |= INSTRLIST_ONCEONLY_LOUDNESS;
  630.                 *RequiredDefinitions |= INSTRLIST_REQUIRED_LOUDNESS;
  631.             }
  632.         else if (GetTokenKeywordTag(Token) == eKeywordFrequencylfo)
  633.             {
  634.                 unsigned long                            LFORequired;
  635.                 LFOSpecRec*                                LFO;
  636.  
  637.                 /* allocate the LFO */
  638.                 LFO = NewLFOSpecifier();
  639.                 if (LFO == NIL)
  640.                     {
  641.                      LFOAllocFailurePoint1:
  642.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  643.                         return eBuildInstrOutOfMemory;
  644.                     }
  645.                 if (!LFOListSpecAppendNewEntry(GetInstrumentFrequencyLFOList(Instrument),LFO))
  646.                     {
  647.                      LFOAllocFailurePoint2:
  648.                         DisposeLFOSpecifier(LFO);
  649.                         goto LFOAllocFailurePoint1;
  650.                     }
  651.  
  652.                 /* open paren */
  653.                 Token = GetNextToken(Scanner);
  654.                 if (Token == NIL)
  655.                     {
  656.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  657.                         return eBuildInstrOutOfMemory;
  658.                     }
  659.                 if (GetTokenType(Token) != eTokenOpenParen)
  660.                     {
  661.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  662.                         return eBuildInstrExpectedOpenParen;
  663.                     }
  664.  
  665.                 /* parse the low frequency operator */
  666.                 LFORequired = 0;
  667.                 Error = ParseLfoDefinition(LFO,Scanner,ErrorLine,&LFORequired,0,WaveTableList,
  668.                     AlgoWaveTableList);
  669.                 if (Error != eBuildInstrNoError)
  670.                     {
  671.                         return Error;
  672.                     }
  673.                 if (LFORequired != LFODEFINITION_REQUIREDMASK)
  674.                     {
  675.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  676.                         return eBuildInstrSomeRequiredLFOParamsMissing;
  677.                     }
  678.  
  679.                 /* close paren */
  680.                 Token = GetNextToken(Scanner);
  681.                 if (Token == NIL)
  682.                     {
  683.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  684.                         return eBuildInstrOutOfMemory;
  685.                     }
  686.                 if (GetTokenType(Token) != eTokenCloseParen)
  687.                     {
  688.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  689.                         return eBuildInstrExpectedCloseParen;
  690.                     }
  691.             }
  692.         else if (GetTokenKeywordTag(Token) == eKeywordOscillator)
  693.             {
  694.                 char*                                            Identifier;
  695.                 unsigned long                            OscillatorRequired;
  696.                 OscillatorRec*                        Oscillator;
  697.  
  698.                 /* allocate a new oscillator & add it to the instrument */
  699.                 Oscillator = NewOscillatorSpecifier();
  700.                 if (Oscillator == NIL)
  701.                     {
  702.                      OscillatorAllocFailurePoint1:
  703.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  704.                         return eBuildInstrOutOfMemory;
  705.                     }
  706.                 if (!AppendOscillatorToList(GetInstrumentOscillatorList(Instrument),Oscillator))
  707.                     {
  708.                      OscillatorAllocFailurePoint2:
  709.                         DisposeOscillatorSpecifier(Oscillator);
  710.                         goto OscillatorAllocFailurePoint1;
  711.                     }
  712.  
  713.                 /* get the oscillator's name */
  714.                 Error = ParseIdentifier(Scanner,ErrorLine,&Identifier);
  715.                 if (Error != eBuildInstrNoError)
  716.                     {
  717.                         return Error;
  718.                     }
  719.                 CheckPtrExistence(Identifier);
  720.                 PutOscillatorName(Oscillator,Identifier);
  721.  
  722.                 /* eat the open paren */
  723.                 Token = GetNextToken(Scanner);
  724.                 if (Token == NIL)
  725.                     {
  726.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  727.                         return eBuildInstrOutOfMemory;
  728.                     }
  729.                 if (GetTokenType(Token) != eTokenOpenParen)
  730.                     {
  731.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  732.                         return eBuildInstrExpectedOpenParen;
  733.                     }
  734.  
  735.                 /* parse oscillator */
  736.                 OscillatorRequired = 0;
  737.                 Error = ParseOscillatorDefinition(Oscillator,Scanner,ErrorLine,
  738.                     &OscillatorRequired,0,WaveTableList,AlgoWaveTableList);
  739.                 if (Error != eBuildInstrNoError)
  740.                     {
  741.                         return Error;
  742.                     }
  743.                 if (OscillatorRequired != OSCILLATORDEFINITION_REQUIREDMASK)
  744.                     {
  745.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  746.                         return eBuildInstrSomeRequiredOscillatorParamsMissing;
  747.                     }
  748.  
  749.                 /* resolve sample/wave table data references */
  750.                 switch (OscillatorGetWhatKindItIs(Oscillator))
  751.                     {
  752.                         default:
  753.                             EXECUTE(PRERR(ForceAbort,"ParseInstrElem:  bad oscillator type"));
  754.                             break;
  755.                         case eOscillatorSampled:
  756.                             if (!ResolveSamplesInSampleList(OscillatorGetSampleIntervalList(
  757.                                 Oscillator),SampleList,AlgoSampList))
  758.                                 {
  759.                                     *ErrorLine = GetCurrentLineNumber(Scanner);
  760.                                     return eBuildInstrSomeSamplesDontExist;
  761.                                 }
  762.                             break;
  763.                         case eOscillatorWaveTable:
  764.                             if (!ResolveWaveTablesInSampleList(OscillatorGetSampleIntervalList(
  765.                                 Oscillator),WaveTableList,AlgoWaveTableList))
  766.                                 {
  767.                                     *ErrorLine = GetCurrentLineNumber(Scanner);
  768.                                     return eBuildInstrSomeWaveTablesDontExist;
  769.                                 }
  770.                             break;
  771.                     }
  772.  
  773.                 /* eat the close paren */
  774.                 Token = GetNextToken(Scanner);
  775.                 if (Token == NIL)
  776.                     {
  777.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  778.                         return eBuildInstrOutOfMemory;
  779.                     }
  780.                 if (GetTokenType(Token) != eTokenCloseParen)
  781.                     {
  782.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  783.                         return eBuildInstrExpectedCloseParen;
  784.                     }
  785.  
  786.                 *RequiredDefinitions |= INSTRLIST_REQUIRED_OSCILLATOR;
  787.             }
  788.         else
  789.             {
  790.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  791.                 return eBuildInstrExpectedInstrumentMember;
  792.             }
  793.  
  794.         return eBuildInstrNoError;
  795.     }
  796.  
  797.  
  798.  
  799.  
  800. /*   80:   <number>                ::= <integertoken> */
  801. /*   81:                           ::= <floattoken> */
  802. /* FIRST SET: */
  803. /*  <number>                : {<integertoken>, <floattoken>} */
  804. /* FOLLOW SET: */
  805. /*  <number>                : {<integertoken>, <floattoken>, ), ;, type, */
  806. /*       exponential, linear, to, sustainpoint, ampaccent1, ampaccent2, */
  807. /*       ampaccent3, ampaccent4, ampfreq, rateaccent1, rateaccent2, rateaccent3, */
  808. /*       rateaccent4, ratefreq, originadjust, <number>, <env_point_list>, */
  809. /*       <env_point_elem>, <env_attributes>, <env_one_attribute>} */
  810. static BuildInstrErrors            ParseNumber(ScannerRec* Scanner, long* ErrorLine,
  811.                                                             double* NumberOut)
  812.     {
  813.         TokenRec*                                    Token;
  814.         MyBoolean                                    Negative;
  815.  
  816.         CheckPtrExistence(Scanner);
  817.  
  818.         Negative = False;
  819.  
  820.      GetAnotherToken:
  821.         Token = GetNextToken(Scanner);
  822.         if (Token == NIL)
  823.             {
  824.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  825.                 return eBuildInstrOutOfMemory;
  826.             }
  827.  
  828.         switch (GetTokenType(Token))
  829.             {
  830.                 default:
  831.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  832.                     return eBuildInstrExpectedNumber;
  833.                 case eTokenInteger:
  834.                     *NumberOut = GetTokenIntegerValue(Token);
  835.                     break;
  836.                 case eTokenSingle:
  837.                     *NumberOut = GetTokenSingleValue(Token);
  838.                     break;
  839.                 case eTokenDouble:
  840.                     *NumberOut = GetTokenDoubleValue(Token);
  841.                     break;
  842.                 case eTokenFixed:
  843.                     *NumberOut = largefixed2double(GetTokenFixedValue(Token));
  844.                     break;
  845.                 case eTokenMinus:
  846.                     Negative = !Negative;
  847.                     goto GetAnotherToken;
  848.             }
  849.  
  850.         if (Negative)
  851.             {
  852.                 *NumberOut = - *NumberOut;
  853.             }
  854.  
  855.         return eBuildInstrNoError;
  856.     }
  857.  
  858.  
  859.  
  860.  
  861. /*    7:   <lfo_definition>        ::= <lfo_elem> ; <lfo_definition> */
  862. /*    8:                           ::=  */
  863. /* FIRST SET: */
  864. /*  <lfo_definition>        : {oscillator, freqenvelope, modulation, */
  865. /*       ampenvelope, <lfo_elem>} */
  866. /* FOLLOW SET: */
  867. /*  <lfo_definition>        : {)} */
  868. static BuildInstrErrors            ParseLfoDefinition(LFOSpecRec* LFO, ScannerRec* Scanner,
  869.                                                             long* ErrorLine, unsigned long* RequiredDefinitions,
  870.                                                             unsigned long OnceOnlyDefinitions,
  871.                                                             struct WaveTableListRec* WaveTableList,
  872.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  873.     {
  874.         TokenRec*                                    Token;
  875.         BuildInstrErrors                    Error;
  876.  
  877.         CheckPtrExistence(LFO);
  878.         CheckPtrExistence(Scanner);
  879.  
  880.         Token = GetNextToken(Scanner);
  881.         if (Token == NIL)
  882.             {
  883.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  884.                 return eBuildInstrOutOfMemory;
  885.             }
  886.  
  887.         if (GetTokenType(Token) == eTokenCloseParen)
  888.             {
  889.                 UngetToken(Scanner,Token);
  890.                 return eBuildInstrNoError;
  891.             }
  892.          else
  893.             {
  894.                 UngetToken(Scanner,Token);
  895.  
  896.                 Error = ParseLfoElem(LFO,Scanner,ErrorLine,RequiredDefinitions,
  897.                     &OnceOnlyDefinitions,WaveTableList,AlgoWaveTableList);
  898.                 if (Error != eBuildInstrNoError)
  899.                     {
  900.                         return Error;
  901.                     }
  902.  
  903.                 /* get semicolon */
  904.                 Token = GetNextToken(Scanner);
  905.                 if (Token == NIL)
  906.                     {
  907.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  908.                         return eBuildInstrOutOfMemory;
  909.                     }
  910.                 if (GetTokenType(Token) != eTokenSemicolon)
  911.                     {
  912.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  913.                         return eBuildInstrExpectedSemicolon;
  914.                     }
  915.  
  916.                 return ParseLfoDefinition(LFO,Scanner,ErrorLine,RequiredDefinitions,
  917.                     OnceOnlyDefinitions,WaveTableList,AlgoWaveTableList);
  918.             }
  919.  
  920.         EXECUTE(PRERR(ForceAbort,"ParseLfoDefinition:  control reached end of function"));
  921.     }
  922.  
  923.  
  924.  
  925.  
  926. /* the identifier string returned from here is NOT trash-tracker allocated. */
  927. /*   78:   <identifier>            ::= <identifiertoken> */
  928. /*   79:                           ::= <stringtoken> */
  929. /* FIRST SET: */
  930. /*  <identifier>            : {<identifiertoken>, <stringtoken>} */
  931. /* FOLLOW SET: */
  932. /*  <identifier>            : {<integertoken>, <floattoken>, (, scale, */
  933. /*       <number>} */
  934. static BuildInstrErrors            ParseIdentifier(ScannerRec* Scanner, long* ErrorLine,
  935.                                                             char** IdentifierOut)
  936.     {
  937.         TokenRec*                                    Token;
  938.  
  939.         CheckPtrExistence(Scanner);
  940.  
  941.         Token = GetNextToken(Scanner);
  942.         if (Token == NIL)
  943.             {
  944.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  945.                 return eBuildInstrOutOfMemory;
  946.             }
  947.  
  948.         if (GetTokenType(Token) == eTokenIdentifier)
  949.             {
  950.                 *IdentifierOut = CopyPtr(GetTokenIdentifierString(Token));
  951.             }
  952.         else if (GetTokenType(Token) == eTokenString)
  953.             {
  954.                 *IdentifierOut = CopyPtr(GetTokenStringValue(Token));
  955.             }
  956.         else
  957.             {
  958.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  959.                 return eBuildInstrExpectedStringOrIdentifier;
  960.             }
  961.  
  962.         if (*IdentifierOut == NIL)
  963.             {
  964.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  965.                 return eBuildInstrOutOfMemory;
  966.             }
  967.         SetTag(*IdentifierOut,"BuildInstr: ParseIdentifier");
  968.  
  969.         return eBuildInstrNoError;
  970.     }
  971.  
  972.  
  973.  
  974.  
  975. /*   27:   <oscillator_definition> ::= <oscillator_elem> ; */
  976. /*       <oscillator_definition> */
  977. /*   28:                           ::=  */
  978. /* FIRST SET: */
  979. /*  <oscillator_definition> : {loudness, type, samplelist, modulators, */
  980. /*       freqmultiplier, freqdivisor, makeoutput, loudnessenvelope, */
  981. /*       loudnesslfo, indexenvelope, indexlfo, <oscillator_elem>} */
  982. /* FOLLOW SET: */
  983. /*  <oscillator_definition> : {)} */
  984. static BuildInstrErrors            ParseOscillatorDefinition(OscillatorRec* Oscillator,
  985.                                                             ScannerRec* Scanner, long* ErrorLine,
  986.                                                             unsigned long* RequiredDefinitions,
  987.                                                             unsigned long OnceOnlyDefinitions,
  988.                                                             struct WaveTableListRec* WaveTableList,
  989.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  990.     {
  991.         TokenRec*                                    Token;
  992.         BuildInstrErrors                    Error;
  993.  
  994.         CheckPtrExistence(Oscillator);
  995.         CheckPtrExistence(Scanner);
  996.  
  997.         Token = GetNextToken(Scanner);
  998.         if (Token == NIL)
  999.             {
  1000.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1001.                 return eBuildInstrOutOfMemory;
  1002.             }
  1003.  
  1004.         if (GetTokenType(Token) == eTokenCloseParen)
  1005.             {
  1006.                 UngetToken(Scanner,Token);
  1007.                 return eBuildInstrNoError;
  1008.             }
  1009.          else
  1010.             {
  1011.                 UngetToken(Scanner,Token);
  1012.  
  1013.                 Error = ParseOscillatorElem(Oscillator,Scanner,ErrorLine,RequiredDefinitions,
  1014.                     &OnceOnlyDefinitions,WaveTableList,AlgoWaveTableList);
  1015.                 if (Error != eBuildInstrNoError)
  1016.                     {
  1017.                         return Error;
  1018.                     }
  1019.  
  1020.                 /* get semicolon */
  1021.                 Token = GetNextToken(Scanner);
  1022.                 if (Token == NIL)
  1023.                     {
  1024.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1025.                         return eBuildInstrOutOfMemory;
  1026.                     }
  1027.                 if (GetTokenType(Token) != eTokenSemicolon)
  1028.                     {
  1029.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1030.                         return eBuildInstrExpectedSemicolon;
  1031.                     }
  1032.  
  1033.                 return ParseOscillatorDefinition(Oscillator,Scanner,ErrorLine,
  1034.                     RequiredDefinitions,OnceOnlyDefinitions,WaveTableList,AlgoWaveTableList);
  1035.             }
  1036.  
  1037.         EXECUTE(PRERR(ForceAbort,"ParseOscillatorDefinition:  control reached end of function"));
  1038.     }
  1039.  
  1040.  
  1041.  
  1042.  
  1043. /*    9:   <lfo_elem>              ::= freqenvelope ( <envelope_definition> ) */
  1044. /*   10:                           ::= ampenvelope ( <envelope_definition> ) */
  1045. /*   11:                           ::= oscillator <oscillator_type> */
  1046. /*   12:                           ::= modulation <modulation_type> */
  1047. /* FIRST SET: */
  1048. /*  <lfo_elem>              : {oscillator, freqenvelope, modulation, ampenvelope} */
  1049. /* FOLLOW SET: */
  1050. /*  <lfo_elem>              : {;} */
  1051. static BuildInstrErrors            ParseLfoElem(LFOSpecRec* LFO, ScannerRec* Scanner,
  1052.                                                             long* ErrorLine, unsigned long* RequiredDefinitions,
  1053.                                                             unsigned long* OnceOnlyDefinitions,
  1054.                                                             struct WaveTableListRec* WaveTableList,
  1055.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  1056.     {
  1057.         TokenRec*                                    Token;
  1058.         BuildInstrErrors                    Error;
  1059.         unsigned long                            Required;
  1060.  
  1061.         CheckPtrExistence(LFO);
  1062.         CheckPtrExistence(Scanner);
  1063.  
  1064.         Token = GetNextToken(Scanner);
  1065.         if (Token == NIL)
  1066.             {
  1067.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1068.                 return eBuildInstrOutOfMemory;
  1069.             }
  1070.         if (GetTokenType(Token) != eTokenKeyword)
  1071.             {
  1072.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1073.                 return eBuildInstrExpectedLFOMember;
  1074.             }
  1075.  
  1076.         switch (GetTokenKeywordTag(Token))
  1077.             {
  1078.                 default:
  1079.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  1080.                     return eBuildInstrExpectedLFOMember;
  1081.  
  1082.                 case eKeywordFreqenvelope:
  1083.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_FREQENVELOPE) != 0)
  1084.                         {
  1085.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1086.                             return eBuildInstrMultipleLFOFreqEnvelope;
  1087.                         }
  1088.  
  1089.                     /* open paren */
  1090.                     Token = GetNextToken(Scanner);
  1091.                     if (Token == NIL)
  1092.                         {
  1093.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1094.                             return eBuildInstrOutOfMemory;
  1095.                         }
  1096.                     if (GetTokenType(Token) != eTokenOpenParen)
  1097.                         {
  1098.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1099.                             return eBuildInstrExpectedOpenParen;
  1100.                         }
  1101.  
  1102.                     Required = 0;
  1103.                     Error = ParseEnvelopeDefinition(GetLFOSpecFrequencyEnvelope(LFO),
  1104.                         Scanner,ErrorLine,&Required,0);
  1105.                     if (Error != eBuildInstrNoError)
  1106.                         {
  1107.                             return Error;
  1108.                         }
  1109.                     if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  1110.                         {
  1111.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1112.                             return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1113.                         }
  1114.  
  1115.                     /* close paren */
  1116.                     Token = GetNextToken(Scanner);
  1117.                     if (Token == NIL)
  1118.                         {
  1119.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1120.                             return eBuildInstrOutOfMemory;
  1121.                         }
  1122.                     if (GetTokenType(Token) != eTokenCloseParen)
  1123.                         {
  1124.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1125.                             return eBuildInstrExpectedCloseParen;
  1126.                         }
  1127.  
  1128.                     *RequiredDefinitions |= LFODEFINITION_REQUIRED_FREQENVELOPE;
  1129.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_FREQENVELOPE;
  1130.                     break;
  1131.  
  1132.                 case eKeywordAmpenvelope:
  1133.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_AMPENVELOPE) != 0)
  1134.                         {
  1135.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1136.                             return eBuildInstrMultipleLFOAmpEnvelope;
  1137.                         }
  1138.  
  1139.                     /* open paren */
  1140.                     Token = GetNextToken(Scanner);
  1141.                     if (Token == NIL)
  1142.                         {
  1143.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1144.                             return eBuildInstrOutOfMemory;
  1145.                         }
  1146.                     if (GetTokenType(Token) != eTokenOpenParen)
  1147.                         {
  1148.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1149.                             return eBuildInstrExpectedOpenParen;
  1150.                         }
  1151.  
  1152.                     Required = 0;
  1153.                     Error = ParseEnvelopeDefinition(GetLFOSpecAmplitudeEnvelope(LFO),
  1154.                         Scanner,ErrorLine,&Required,0);
  1155.                     if (Error != eBuildInstrNoError)
  1156.                         {
  1157.                             return Error;
  1158.                         }
  1159.                     if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  1160.                         {
  1161.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1162.                             return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1163.                         }
  1164.  
  1165.                     /* close paren */
  1166.                     Token = GetNextToken(Scanner);
  1167.                     if (Token == NIL)
  1168.                         {
  1169.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1170.                             return eBuildInstrOutOfMemory;
  1171.                         }
  1172.                     if (GetTokenType(Token) != eTokenCloseParen)
  1173.                         {
  1174.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1175.                             return eBuildInstrExpectedCloseParen;
  1176.                         }
  1177.  
  1178.                     *RequiredDefinitions |= LFODEFINITION_REQUIRED_AMPENVELOPE;
  1179.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_AMPENVELOPE;
  1180.                     break;
  1181.  
  1182.                 case eKeywordOscillator:
  1183.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_OSCILLATORTYPE) != 0)
  1184.                         {
  1185.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1186.                             return eBuildInstrMultipleLFOOscillatorType;
  1187.                         }
  1188.  
  1189.                     /*  13:   <oscillator_type>       ::= constant */
  1190.                     /*  14:                           ::= signsine */
  1191.                     /*  15:                           ::= plussine */
  1192.                     /*  16:                           ::= signtriangle */
  1193.                     /*  17:                           ::= plustriangle */
  1194.                     /*  18:                           ::= signsquare */
  1195.                     /*  19:                           ::= plussquare */
  1196.                     /*  20:                           ::= signramp */
  1197.                     /*  21:                           ::= plusramp */
  1198.                     /*  22:                           ::= signlinfuzz */
  1199.                     /*  23:                           ::= pluslinfuzz */
  1200.                     /*  XX:                           ::= wavetable ( <samplelist_definition> */
  1201.                     /*                                    ) ( <envelope_definition> ) */
  1202.                     Token = GetNextToken(Scanner);
  1203.                     if (Token == NIL)
  1204.                         {
  1205.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1206.                             return eBuildInstrOutOfMemory;
  1207.                         }
  1208.                     if (GetTokenType(Token) != eTokenKeyword)
  1209.                         {
  1210.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1211.                             return eBuildInstrExpectedLFOOscillatorType;
  1212.                         }
  1213.                     switch (GetTokenKeywordTag(Token))
  1214.                         {
  1215.                             default:
  1216.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1217.                                 return eBuildInstrExpectedLFOOscillatorType;
  1218.                             case eKeywordConstant:
  1219.                                 SetLFOSpecOscillatorType(LFO,eLFOConstant1);
  1220.                                 break;
  1221.                             case eKeywordSignsine:
  1222.                                 SetLFOSpecOscillatorType(LFO,eLFOSignedSine);
  1223.                                 break;
  1224.                             case eKeywordPlussine:
  1225.                                 SetLFOSpecOscillatorType(LFO,eLFOPositiveSine);
  1226.                                 break;
  1227.                             case eKeywordSigntriangle:
  1228.                                 SetLFOSpecOscillatorType(LFO,eLFOSignedTriangle);
  1229.                                 break;
  1230.                             case eKeywordPlustriangle:
  1231.                                 SetLFOSpecOscillatorType(LFO,eLFOPositiveTriangle);
  1232.                                 break;
  1233.                             case eKeywordSignsquare:
  1234.                                 SetLFOSpecOscillatorType(LFO,eLFOSignedSquare);
  1235.                                 break;
  1236.                             case eKeywordPlussquare:
  1237.                                 SetLFOSpecOscillatorType(LFO,eLFOPositiveSquare);
  1238.                                 break;
  1239.                             case eKeywordSignramp:
  1240.                                 SetLFOSpecOscillatorType(LFO,eLFOSignedRamp);
  1241.                                 break;
  1242.                             case eKeywordPlusramp:
  1243.                                 SetLFOSpecOscillatorType(LFO,eLFOPositiveRamp);
  1244.                                 break;
  1245.                             case eKeywordSignlinfuzz:
  1246.                                 SetLFOSpecOscillatorType(LFO,eLFOSignedLinearFuzz);
  1247.                                 break;
  1248.                             case eKeywordPluslinfuzz:
  1249.                                 SetLFOSpecOscillatorType(LFO,eLFOPositiveLinearFuzz);
  1250.                                 break;
  1251.  
  1252.  
  1253.                             case eKeywordWavetable:
  1254.                                 SetLFOSpecOscillatorType(LFO,eLFOWaveTable);
  1255.  
  1256.                                 /* open paren */
  1257.                                 Token = GetNextToken(Scanner);
  1258.                                 if (Token == NIL)
  1259.                                     {
  1260.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1261.                                         return eBuildInstrOutOfMemory;
  1262.                                     }
  1263.                                 if (GetTokenType(Token) != eTokenOpenParen)
  1264.                                     {
  1265.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1266.                                         return eBuildInstrExpectedOpenParen;
  1267.                                     }
  1268.  
  1269.                                 Error = ParseSamplelistDefinition(GetLFOSpecSampleSelector(LFO),
  1270.                                     Scanner,ErrorLine);
  1271.                                 if (Error != eBuildInstrNoError)
  1272.                                     {
  1273.                                         return Error;
  1274.                                     }
  1275.                                 if (!ResolveWaveTablesInSampleList(GetLFOSpecSampleSelector(LFO),
  1276.                                     WaveTableList,AlgoWaveTableList))
  1277.                                     {
  1278.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1279.                                         return eBuildInstrSomeWaveTablesDontExist;
  1280.                                     }
  1281.  
  1282.                                 /* close paren */
  1283.                                 Token = GetNextToken(Scanner);
  1284.                                 if (Token == NIL)
  1285.                                     {
  1286.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1287.                                         return eBuildInstrOutOfMemory;
  1288.                                     }
  1289.                                 if (GetTokenType(Token) != eTokenCloseParen)
  1290.                                     {
  1291.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1292.                                         return eBuildInstrExpectedCloseParen;
  1293.                                     }
  1294.  
  1295.                                 /* open paren */
  1296.                                 Token = GetNextToken(Scanner);
  1297.                                 if (Token == NIL)
  1298.                                     {
  1299.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1300.                                         return eBuildInstrOutOfMemory;
  1301.                                     }
  1302.                                 if (GetTokenType(Token) != eTokenOpenParen)
  1303.                                     {
  1304.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1305.                                         return eBuildInstrExpectedOpenParen;
  1306.                                     }
  1307.  
  1308.                                 Required = 0;
  1309.                                 Error = ParseEnvelopeDefinition(GetLFOSpecWaveTableIndexEnvelope(LFO),
  1310.                                     Scanner,ErrorLine,&Required,0);
  1311.                                 if (Error != eBuildInstrNoError)
  1312.                                     {
  1313.                                         return Error;
  1314.                                     }
  1315.                                 if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  1316.                                     {
  1317.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1318.                                         return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1319.                                     }
  1320.  
  1321.                                 /* close paren */
  1322.                                 Token = GetNextToken(Scanner);
  1323.                                 if (Token == NIL)
  1324.                                     {
  1325.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1326.                                         return eBuildInstrOutOfMemory;
  1327.                                     }
  1328.                                 if (GetTokenType(Token) != eTokenCloseParen)
  1329.                                     {
  1330.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1331.                                         return eBuildInstrExpectedCloseParen;
  1332.                                     }
  1333.                                 break;
  1334.                         }
  1335.  
  1336.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_OSCILLATORTYPE;
  1337.                     break;
  1338.  
  1339.                 case eKeywordModulation:
  1340.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_MODULATIONTYPE) != 0)
  1341.                         {
  1342.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1343.                             return eBuildInstrMultipleLFOModulationType;
  1344.                         }
  1345.  
  1346.                     /*  24:   <modulation_type>       ::= additive */
  1347.                     /*  25:                           ::= multiplicative */
  1348.                     /*  26:                           ::= inversemult */
  1349.                     Token = GetNextToken(Scanner);
  1350.                     if (Token == NIL)
  1351.                         {
  1352.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1353.                             return eBuildInstrOutOfMemory;
  1354.                         }
  1355.                     if (GetTokenType(Token) != eTokenKeyword)
  1356.                         {
  1357.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1358.                             return eBuildInstrExpectedLFOModulationType;
  1359.                         }
  1360.                     switch (GetTokenKeywordTag(Token))
  1361.                         {
  1362.                             default:
  1363.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1364.                                 return eBuildInstrExpectedLFOModulationType;
  1365.                             case eKeywordAdditive:
  1366.                                 SetLFOSpecModulationMode(LFO,eLFOAdditive);
  1367.                                 break;
  1368.                             case eKeywordMultiplicative:
  1369.                                 SetLFOSpecModulationMode(LFO,eLFOMultiplicative);
  1370.                                 break;
  1371.                             case eKeywordInversemult:
  1372.                                 SetLFOSpecModulationMode(LFO,eLFOInverseMultiplicative);
  1373.                                 break;
  1374.                         }
  1375.  
  1376.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_MODULATIONTYPE;
  1377.                     break;
  1378.  
  1379.                 case eKeywordLinear:
  1380.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_ADDINGMODE) != 0)
  1381.                         {
  1382.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1383.                             return eBuildInstrMultipleLFOAddingMode;
  1384.                         }
  1385.  
  1386.                     SetLFOSpecAddingMode(LFO,eLFOArithmetic);
  1387.  
  1388.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_ADDINGMODE;
  1389.                     break;
  1390.  
  1391.                 case eKeywordExponential:
  1392.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_ADDINGMODE) != 0)
  1393.                         {
  1394.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1395.                             return eBuildInstrMultipleLFOAddingMode;
  1396.                         }
  1397.  
  1398.                     SetLFOSpecAddingMode(LFO,eLFOGeometric);
  1399.  
  1400.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_ADDINGMODE;
  1401.                     break;
  1402.             }
  1403.  
  1404.         return eBuildInstrNoError;
  1405.     }
  1406.  
  1407.  
  1408.  
  1409.  
  1410. /*   29:   <oscillator_elem>       ::= type <oscillator_type> */
  1411. /*   30:                           ::= samplelist ( <samplelist_definition> ) */
  1412. /*   31:                           ::= modulators ( <modulator_list> ) */
  1413. /*   32:                           ::= loudness <number> */
  1414. /*   33:                           ::= freqmultiplier <number> */
  1415. /*   34:                           ::= freqdivisor <integer> */
  1416. /*   35:                           ::= makeoutput <boolean> */
  1417. /*   36:                           ::= loudnessenvelope ( <envelope_definition> ) */
  1418. /*   37:                           ::= loudnesslfo ( <lfo_definition> ) */
  1419. /*   38:                           ::= indexenvelope ( <envelope_definition> ) */
  1420. /*   39:                           ::= indexlfo ( <lfo_definition> ) */
  1421. /*   XXX:                          ::= stereobias <number> */
  1422. /*   XXX:                          ::= displacement <number> */
  1423. /* FIRST SET: */
  1424. /*  <oscillator_elem>       : {loudness, type, samplelist, modulators, */
  1425. /*       freqmultiplier, freqdivisor, makeoutput, loudnessenvelope, */
  1426. /*       loudnesslfo, indexenvelope, indexlfo} */
  1427. /* FOLLOW SET: */
  1428. /*  <oscillator_elem>       : {;} */
  1429. static BuildInstrErrors            ParseOscillatorElem(OscillatorRec* Oscillator,
  1430.                                                             ScannerRec* Scanner, long* ErrorLine,
  1431.                                                             unsigned long* RequiredDefinitions,
  1432.                                                             unsigned long* OnceOnlyDefinitions,
  1433.                                                             struct WaveTableListRec* WaveTableList,
  1434.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  1435.     {
  1436.         TokenRec*                                    Token;
  1437.         BuildInstrErrors                    Error;
  1438.         double                                        Number;
  1439.         unsigned long                            Required;
  1440.  
  1441.         CheckPtrExistence(Oscillator);
  1442.         CheckPtrExistence(Scanner);
  1443.  
  1444.         Token = GetNextToken(Scanner);
  1445.         if (Token == NIL)
  1446.             {
  1447.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1448.                 return eBuildInstrOutOfMemory;
  1449.             }
  1450.         if (GetTokenType(Token) != eTokenKeyword)
  1451.             {
  1452.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1453.                 return eBuildInstrExpectedOscillatorMember;
  1454.             }
  1455.  
  1456.         switch (GetTokenKeywordTag(Token))
  1457.             {
  1458.                 default:
  1459.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  1460.                     return eBuildInstrExpectedOscillatorMember;
  1461.  
  1462.                 case eKeywordType:
  1463.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_TYPE) != 0)
  1464.                         {
  1465.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1466.                             return eBuildInstrMultipleOscType;
  1467.                         }
  1468.  
  1469.                     /*  40:   <oscillator_type>       ::= sampled */
  1470.                     /*  41:                           ::= wavetable */
  1471.                     Token = GetNextToken(Scanner);
  1472.                     if (Token == NIL)
  1473.                         {
  1474.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1475.                             return eBuildInstrOutOfMemory;
  1476.                         }
  1477.                     if (GetTokenType(Token) != eTokenKeyword)
  1478.                         {
  1479.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1480.                             return eBuildInstrExpectedOscType;
  1481.                         }
  1482.                     switch (GetTokenKeywordTag(Token))
  1483.                         {
  1484.                             default:
  1485.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1486.                                 return eBuildInstrExpectedOscType;
  1487.                             case eKeywordSampled:
  1488.                                 OscillatorSetTheType(Oscillator,eOscillatorSampled);
  1489.                                 break;
  1490.                             case eKeywordWavetable:
  1491.                                 OscillatorSetTheType(Oscillator,eOscillatorWaveTable);
  1492.                                 break;
  1493.                         }
  1494.  
  1495.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_TYPE;
  1496.                     *RequiredDefinitions |= OSCILLATORDEFINITION_REQUIRED_TYPE;
  1497.                     break;
  1498.  
  1499.                 case eKeywordSamplelist:
  1500.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_SAMPLELIST) != 0)
  1501.                         {
  1502.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1503.                             return eBuildInstrMultipleOscSampleList;
  1504.                         }
  1505.  
  1506.                     /* open paren */
  1507.                     Token = GetNextToken(Scanner);
  1508.                     if (Token == NIL)
  1509.                         {
  1510.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1511.                             return eBuildInstrOutOfMemory;
  1512.                         }
  1513.                     if (GetTokenType(Token) != eTokenOpenParen)
  1514.                         {
  1515.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1516.                             return eBuildInstrExpectedOpenParen;
  1517.                         }
  1518.  
  1519.                     Error = ParseSamplelistDefinition(OscillatorGetSampleIntervalList(Oscillator),
  1520.                         Scanner,ErrorLine);
  1521.                     if (Error != eBuildInstrNoError)
  1522.                         {
  1523.                             return Error;
  1524.                         }
  1525.  
  1526.                     /* close paren */
  1527.                     Token = GetNextToken(Scanner);
  1528.                     if (Token == NIL)
  1529.                         {
  1530.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1531.                             return eBuildInstrOutOfMemory;
  1532.                         }
  1533.                     if (GetTokenType(Token) != eTokenCloseParen)
  1534.                         {
  1535.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1536.                             return eBuildInstrExpectedCloseParen;
  1537.                         }
  1538.  
  1539.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_SAMPLELIST;
  1540.                     *RequiredDefinitions |= OSCILLATORDEFINITION_REQUIRED_SAMPLELIST;
  1541.                     break;
  1542.  
  1543.                 case eKeywordModulators:
  1544.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_MODULATORS) != 0)
  1545.                         {
  1546.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1547.                             return eBuildInstrMultipleOscModulators;
  1548.                         }
  1549.  
  1550.                     /* open paren */
  1551.                     Token = GetNextToken(Scanner);
  1552.                     if (Token == NIL)
  1553.                         {
  1554.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1555.                             return eBuildInstrOutOfMemory;
  1556.                         }
  1557.                     if (GetTokenType(Token) != eTokenOpenParen)
  1558.                         {
  1559.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1560.                             return eBuildInstrExpectedOpenParen;
  1561.                         }
  1562.  
  1563.                     Error = ParseModulatorList(OscillatorGetModulatorInputList(Oscillator),
  1564.                         Scanner,ErrorLine,WaveTableList,AlgoWaveTableList);
  1565.                     if (Error != eBuildInstrNoError)
  1566.                         {
  1567.                             return Error;
  1568.                         }
  1569.  
  1570.                     /* close paren */
  1571.                     Token = GetNextToken(Scanner);
  1572.                     if (Token == NIL)
  1573.                         {
  1574.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1575.                             return eBuildInstrOutOfMemory;
  1576.                         }
  1577.                     if (GetTokenType(Token) != eTokenCloseParen)
  1578.                         {
  1579.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1580.                             return eBuildInstrExpectedCloseParen;
  1581.                         }
  1582.  
  1583.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_MODULATORS;
  1584.                     break;
  1585.  
  1586.                 case eKeywordLoudness:
  1587.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_LOUDNESS) != 0)
  1588.                         {
  1589.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1590.                             return eBuildInstrMultipleOscLoudness;
  1591.                         }
  1592.  
  1593.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1594.                     if (Error != eBuildInstrNoError)
  1595.                         {
  1596.                             return Error;
  1597.                         }
  1598.                     PutOscillatorNewOutputLoudness(Oscillator,Number);
  1599.  
  1600.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_LOUDNESS;
  1601.                     *RequiredDefinitions |= OSCILLATORDEFINITION_REQUIRED_LOUDNESS;
  1602.                     break;
  1603.  
  1604.                 case eKeywordFreqmultiplier:
  1605.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_FREQMULTIPLIER) != 0)
  1606.                         {
  1607.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1608.                             return eBuildInstrMultipleOscFreqMultiplier;
  1609.                         }
  1610.  
  1611.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1612.                     if (Error != eBuildInstrNoError)
  1613.                         {
  1614.                             return Error;
  1615.                         }
  1616.                     PutOscillatorNewFrequencyFactors(Oscillator,Number,
  1617.                         OscillatorGetFrequencyDivisor(Oscillator));
  1618.  
  1619.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_FREQMULTIPLIER;
  1620.                     break;
  1621.  
  1622.                 case eKeywordFreqdivisor:
  1623.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_FREQDIVISOR) != 0)
  1624.                         {
  1625.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1626.                             return eBuildInstrMultipleOscFreqDivisor;
  1627.                         }
  1628.  
  1629.                     Token = GetNextToken(Scanner);
  1630.                     if (Token == NIL)
  1631.                         {
  1632.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1633.                             return eBuildInstrOutOfMemory;
  1634.                         }
  1635.                     if (GetTokenType(Token) != eTokenInteger)
  1636.                         {
  1637.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1638.                             return eBuildInstrExpectedInteger;
  1639.                         }
  1640.                     PutOscillatorNewFrequencyFactors(Oscillator,
  1641.                         OscillatorGetFrequencyMultiplier(Oscillator),GetTokenIntegerValue(Token));
  1642.  
  1643.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_FREQDIVISOR;
  1644.                     break;
  1645.  
  1646.                 case eKeywordFreqadder:
  1647.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_FREQADDER) != 0)
  1648.                         {
  1649.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1650.                             return eBuildInserMultipleOscFreqAdder;
  1651.                         }
  1652.  
  1653.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1654.                     if (Error != eBuildInstrNoError)
  1655.                         {
  1656.                             return Error;
  1657.                         }
  1658.                     PutOscillatorFrequencyAdder(Oscillator,Number);
  1659.  
  1660.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_FREQADDER;
  1661.                     break;
  1662.  
  1663.                 case eKeywordMakeoutput:
  1664.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_MAKEOUTPUT) != 0)
  1665.                         {
  1666.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1667.                             return eBuildInstrMultipleOscMakeOutput;
  1668.                         }
  1669.  
  1670.                     Token = GetNextToken(Scanner);
  1671.                     if (Token == NIL)
  1672.                         {
  1673.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1674.                             return eBuildInstrOutOfMemory;
  1675.                         }
  1676.                     if (GetTokenType(Token) != eTokenKeyword)
  1677.                         {
  1678.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1679.                             return eBuildInstrExpectedBoolean;
  1680.                         }
  1681.                     switch (GetTokenKeywordTag(Token))
  1682.                         {
  1683.                             default:
  1684.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1685.                                 return eBuildInstrExpectedBoolean;
  1686.                             case eKeywordTrue:
  1687.                                 PutOscillatorIncludeInOutputFlag(Oscillator,True);
  1688.                                 break;
  1689.                             case eKeywordFalse:
  1690.                                 PutOscillatorIncludeInOutputFlag(Oscillator,False);
  1691.                                 break;
  1692.                         }
  1693.  
  1694.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_MAKEOUTPUT;
  1695.                     break;
  1696.  
  1697.                 case eKeywordLoudnessenvelope:
  1698.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_LOUDNESSENVELOPE) != 0)
  1699.                         {
  1700.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1701.                             return eBuildInstrMultipleOscLoudnessEnvelope;
  1702.                         }
  1703.  
  1704.                     /* open paren */
  1705.                     Token = GetNextToken(Scanner);
  1706.                     if (Token == NIL)
  1707.                         {
  1708.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1709.                             return eBuildInstrOutOfMemory;
  1710.                         }
  1711.                     if (GetTokenType(Token) != eTokenOpenParen)
  1712.                         {
  1713.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1714.                             return eBuildInstrExpectedOpenParen;
  1715.                         }
  1716.  
  1717.                     Required = 0;
  1718.                     Error = ParseEnvelopeDefinition(OscillatorGetLoudnessEnvelope(Oscillator),
  1719.                         Scanner,ErrorLine,&Required,0);
  1720.                     if (Error != eBuildInstrNoError)
  1721.                         {
  1722.                             return Error;
  1723.                         }
  1724.                     if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  1725.                         {
  1726.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1727.                             return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1728.                         }
  1729.  
  1730.                     /* close paren */
  1731.                     Token = GetNextToken(Scanner);
  1732.                     if (Token == NIL)
  1733.                         {
  1734.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1735.                             return eBuildInstrOutOfMemory;
  1736.                         }
  1737.                     if (GetTokenType(Token) != eTokenCloseParen)
  1738.                         {
  1739.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1740.                             return eBuildInstrExpectedCloseParen;
  1741.                         }
  1742.  
  1743.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_LOUDNESSENVELOPE;
  1744.                     *RequiredDefinitions |= OSCILLATORDEFINITION_REQUIRED_LOUDNESSENVELOPE;
  1745.                     break;
  1746.  
  1747.                 case eKeywordLoudnesslfo:
  1748.                     {
  1749.                         LFOSpecRec*                    LFO;
  1750.  
  1751.                         /* create the LFO */
  1752.                         LFO = NewLFOSpecifier();
  1753.                         if (LFO == NIL)
  1754.                             {
  1755.                              LoudnessLFOAllocFailurePoint1:
  1756.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1757.                                 return eBuildInstrOutOfMemory;
  1758.                             }
  1759.                         if (!LFOListSpecAppendNewEntry(OscillatorGetLoudnessLFOList(Oscillator),LFO))
  1760.                             {
  1761.                              LoudnessLFOAllocFailurePoint2:
  1762.                                 DisposeLFOSpecifier(LFO);
  1763.                                 goto LoudnessLFOAllocFailurePoint1;
  1764.                             }
  1765.  
  1766.                         /* open paren */
  1767.                         Token = GetNextToken(Scanner);
  1768.                         if (Token == NIL)
  1769.                             {
  1770.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1771.                                 return eBuildInstrOutOfMemory;
  1772.                             }
  1773.                         if (GetTokenType(Token) != eTokenOpenParen)
  1774.                             {
  1775.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1776.                                 return eBuildInstrExpectedOpenParen;
  1777.                             }
  1778.  
  1779.                         Required = 0;
  1780.                         Error = ParseLfoDefinition(LFO,Scanner,ErrorLine,&Required,0,
  1781.                             WaveTableList,AlgoWaveTableList);
  1782.                         if (Error != eBuildInstrNoError)
  1783.                             {
  1784.                                 return Error;
  1785.                             }
  1786.                         if (Required != LFODEFINITION_REQUIREDMASK)
  1787.                             {
  1788.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1789.                                 return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1790.                             }
  1791.  
  1792.                         /* close paren */
  1793.                         Token = GetNextToken(Scanner);
  1794.                         if (Token == NIL)
  1795.                             {
  1796.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1797.                                 return eBuildInstrOutOfMemory;
  1798.                             }
  1799.                         if (GetTokenType(Token) != eTokenCloseParen)
  1800.                             {
  1801.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1802.                                 return eBuildInstrExpectedCloseParen;
  1803.                             }
  1804.                     }
  1805.                     break;
  1806.  
  1807.                 case eKeywordIndexenvelope:
  1808.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_INDEXENVELOPE) != 0)
  1809.                         {
  1810.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1811.                             return eBuildInstrMultipleOscIndexEnvelope;
  1812.                         }
  1813.  
  1814.                     /* open paren */
  1815.                     Token = GetNextToken(Scanner);
  1816.                     if (Token == NIL)
  1817.                         {
  1818.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1819.                             return eBuildInstrOutOfMemory;
  1820.                         }
  1821.                     if (GetTokenType(Token) != eTokenOpenParen)
  1822.                         {
  1823.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1824.                             return eBuildInstrExpectedOpenParen;
  1825.                         }
  1826.  
  1827.                     Required = 0;
  1828.                     Error = ParseEnvelopeDefinition(OscillatorGetExcitationEnvelope(Oscillator),
  1829.                         Scanner,ErrorLine,&Required,0);
  1830.                     if (Error != eBuildInstrNoError)
  1831.                         {
  1832.                             return Error;
  1833.                         }
  1834.                     if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  1835.                         {
  1836.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1837.                             return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1838.                         }
  1839.  
  1840.                     /* close paren */
  1841.                     Token = GetNextToken(Scanner);
  1842.                     if (Token == NIL)
  1843.                         {
  1844.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1845.                             return eBuildInstrOutOfMemory;
  1846.                         }
  1847.                     if (GetTokenType(Token) != eTokenCloseParen)
  1848.                         {
  1849.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1850.                             return eBuildInstrExpectedCloseParen;
  1851.                         }
  1852.  
  1853.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_INDEXENVELOPE;
  1854.                     break;
  1855.  
  1856.                 case eKeywordIndexlfo:
  1857.                     {
  1858.                         LFOSpecRec*                    LFO;
  1859.  
  1860.                         /* create the LFO */
  1861.                         LFO = NewLFOSpecifier();
  1862.                         if (LFO == NIL)
  1863.                             {
  1864.                              IndexLFOAllocFailurePoint1:
  1865.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1866.                                 return eBuildInstrOutOfMemory;
  1867.                             }
  1868.                         if (!LFOListSpecAppendNewEntry(OscillatorGetExcitationLFOList(Oscillator),LFO))
  1869.                             {
  1870.                              IndexLFOAllocFailurePoint2:
  1871.                                 DisposeLFOSpecifier(LFO);
  1872.                                 goto IndexLFOAllocFailurePoint1;
  1873.                             }
  1874.  
  1875.                         /* open paren */
  1876.                         Token = GetNextToken(Scanner);
  1877.                         if (Token == NIL)
  1878.                             {
  1879.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1880.                                 return eBuildInstrOutOfMemory;
  1881.                             }
  1882.                         if (GetTokenType(Token) != eTokenOpenParen)
  1883.                             {
  1884.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1885.                                 return eBuildInstrExpectedOpenParen;
  1886.                             }
  1887.  
  1888.                         Required = 0;
  1889.                         Error = ParseLfoDefinition(LFO,Scanner,ErrorLine,&Required,0,
  1890.                             WaveTableList,AlgoWaveTableList);
  1891.                         if (Error != eBuildInstrNoError)
  1892.                             {
  1893.                                 return Error;
  1894.                             }
  1895.                         if (Required != LFODEFINITION_REQUIREDMASK)
  1896.                             {
  1897.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1898.                                 return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1899.                             }
  1900.  
  1901.                         /* close paren */
  1902.                         Token = GetNextToken(Scanner);
  1903.                         if (Token == NIL)
  1904.                             {
  1905.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1906.                                 return eBuildInstrOutOfMemory;
  1907.                             }
  1908.                         if (GetTokenType(Token) != eTokenCloseParen)
  1909.                             {
  1910.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1911.                                 return eBuildInstrExpectedCloseParen;
  1912.                             }
  1913.                     }
  1914.                     break;
  1915.  
  1916.                 case eKeywordStereobias:
  1917.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_STEREOBIAS) != 0)
  1918.                         {
  1919.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1920.                             return eBuildInstrMultipleOscStereoBias;
  1921.                         }
  1922.  
  1923.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1924.                     if (Error != eBuildInstrNoError)
  1925.                         {
  1926.                             return Error;
  1927.                         }
  1928.                     OscillatorPutStereoBias(Oscillator,Number);
  1929.  
  1930.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_STEREOBIAS;
  1931.                     break;
  1932.  
  1933.                 case eKeywordDisplacement:
  1934.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_TIMEDISPLACEMENT) != 0)
  1935.                         {
  1936.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1937.                             return eBuildInstrMultipleOscDisplacement;
  1938.                         }
  1939.  
  1940.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1941.                     if (Error != eBuildInstrNoError)
  1942.                         {
  1943.                             return Error;
  1944.                         }
  1945.                     OscillatorPutTimeDisplacement(Oscillator,Number);
  1946.  
  1947.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_TIMEDISPLACEMENT;
  1948.                     break;
  1949.  
  1950.                 case eKeywordSurroundbias:
  1951.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_SURROUNDBIAS) != 0)
  1952.                         {
  1953.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1954.                             return eBuildInstrMultipleOscSurroundBias;
  1955.                         }
  1956.  
  1957.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1958.                     if (Error != eBuildInstrNoError)
  1959.                         {
  1960.                             return Error;
  1961.                         }
  1962.                     OscillatorPutSurroundBias(Oscillator,Number);
  1963.  
  1964.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_SURROUNDBIAS;
  1965.                     break;
  1966.             }
  1967.  
  1968.         return eBuildInstrNoError;
  1969.     }
  1970.  
  1971.  
  1972.  
  1973.  
  1974. /*   42:   <envelope_definition>   ::= <envelope_elem> ; <envelope_definition> */
  1975. /*   43:                           ::=  */
  1976. /* FIRST SET: */
  1977. /*  <envelope_definition>   : {totalscaling, points, <envelope_elem>} */
  1978. /* FOLLOW SET: */
  1979. /*  <envelope_definition>   : {)} */
  1980. static BuildInstrErrors            ParseEnvelopeDefinition(EnvelopeRec* Envelope,
  1981.                                                             ScannerRec* Scanner, long* ErrorLine,
  1982.                                                             unsigned long* RequiredDefinitions,
  1983.                                                             unsigned long OnceOnlyDefinitions)
  1984.     {
  1985.         TokenRec*                                    Token;
  1986.         BuildInstrErrors                    Error;
  1987.  
  1988.         CheckPtrExistence(Envelope);
  1989.         CheckPtrExistence(Scanner);
  1990.  
  1991.         Token = GetNextToken(Scanner);
  1992.         if (Token == NIL)
  1993.             {
  1994.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1995.                 return eBuildInstrOutOfMemory;
  1996.             }
  1997.  
  1998.         if (GetTokenType(Token) == eTokenCloseParen)
  1999.             {
  2000.                 UngetToken(Scanner,Token);
  2001.                 return eBuildInstrNoError;
  2002.             }
  2003.          else
  2004.             {
  2005.                 UngetToken(Scanner,Token);
  2006.  
  2007.                 Error = ParseEnvelopeElem(Envelope,Scanner,ErrorLine,RequiredDefinitions,
  2008.                     &OnceOnlyDefinitions);
  2009.                 if (Error != eBuildInstrNoError)
  2010.                     {
  2011.                         return Error;
  2012.                     }
  2013.  
  2014.                 /* get semicolon */
  2015.                 Token = GetNextToken(Scanner);
  2016.                 if (Token == NIL)
  2017.                     {
  2018.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2019.                         return eBuildInstrOutOfMemory;
  2020.                     }
  2021.                 if (GetTokenType(Token) != eTokenSemicolon)
  2022.                     {
  2023.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2024.                         return eBuildInstrExpectedSemicolon;
  2025.                     }
  2026.  
  2027.                 return ParseEnvelopeDefinition(Envelope,Scanner,ErrorLine,RequiredDefinitions,
  2028.                     OnceOnlyDefinitions);
  2029.             }
  2030.  
  2031.         EXECUTE(PRERR(ForceAbort,"ParseEnvelopeDefinition:  control reached end of function"));
  2032.     }
  2033.  
  2034.  
  2035.  
  2036.  
  2037. /*   68:   <samplelist_definition> ::= <samplelist_elem> ; */
  2038. /*       <samplelist_definition> */
  2039. /*   69:                           ::=  */
  2040. /* FIRST SET: */
  2041. /*  <samplelist_definition> : {<identifiertoken>, <stringtoken>, */
  2042. /*       <identifier>, <samplelist_elem>} */
  2043. /* FOLLOW SET: */
  2044. /*  <samplelist_definition> : {)} */
  2045. static BuildInstrErrors            ParseSamplelistDefinition(SampleSelectorRec* SampleList,
  2046.                                                             ScannerRec* Scanner, long* ErrorLine)
  2047.     {
  2048.         TokenRec*                                    Token;
  2049.         BuildInstrErrors                    Error;
  2050.  
  2051.         CheckPtrExistence(SampleList);
  2052.         CheckPtrExistence(Scanner);
  2053.  
  2054.         Token = GetNextToken(Scanner);
  2055.         if (Token == NIL)
  2056.             {
  2057.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2058.                 return eBuildInstrOutOfMemory;
  2059.             }
  2060.  
  2061.         if (GetTokenType(Token) == eTokenCloseParen)
  2062.             {
  2063.                 UngetToken(Scanner,Token);
  2064.                 return eBuildInstrNoError;
  2065.             }
  2066.          else
  2067.             {
  2068.                 UngetToken(Scanner,Token);
  2069.  
  2070.                 Error = ParseSamplelistElem(SampleList,Scanner,ErrorLine);
  2071.                 if (Error != eBuildInstrNoError)
  2072.                     {
  2073.                         return Error;
  2074.                     }
  2075.  
  2076.                 /* get semicolon */
  2077.                 Token = GetNextToken(Scanner);
  2078.                 if (Token == NIL)
  2079.                     {
  2080.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2081.                         return eBuildInstrOutOfMemory;
  2082.                     }
  2083.                 if (GetTokenType(Token) != eTokenSemicolon)
  2084.                     {
  2085.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2086.                         return eBuildInstrExpectedSemicolon;
  2087.                     }
  2088.  
  2089.                 return ParseSamplelistDefinition(SampleList,Scanner,ErrorLine);
  2090.             }
  2091.  
  2092.         EXECUTE(PRERR(ForceAbort,"ParseSamplelistDefinition:  control reached end of function"));
  2093.     }
  2094.  
  2095.  
  2096.  
  2097.  
  2098. /*   71:   <modulator_list>        ::= <modulator_elem> ; <modulator_list> */
  2099. /*   72:                           ::=  */
  2100. /* FIRST SET: */
  2101. /*  <modulator_list>        : {source, <modulator_elem>} */
  2102. /* FOLLOW SET: */
  2103. /*  <modulator_list>        : {)} */
  2104. static BuildInstrErrors            ParseModulatorList(ModulationSpecRec* ModulatorList,
  2105.                                                             ScannerRec* Scanner, long* ErrorLine,
  2106.                                                             struct WaveTableListRec* WaveTableList,
  2107.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  2108.     {
  2109.         TokenRec*                                    Token;
  2110.         BuildInstrErrors                    Error;
  2111.  
  2112.         CheckPtrExistence(ModulatorList);
  2113.         CheckPtrExistence(Scanner);
  2114.  
  2115.         Token = GetNextToken(Scanner);
  2116.         if (Token == NIL)
  2117.             {
  2118.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2119.                 return eBuildInstrOutOfMemory;
  2120.             }
  2121.  
  2122.         if (GetTokenType(Token) == eTokenCloseParen)
  2123.             {
  2124.                 UngetToken(Scanner,Token);
  2125.                 return eBuildInstrNoError;
  2126.             }
  2127.          else
  2128.             {
  2129.                 UngetToken(Scanner,Token);
  2130.  
  2131.                 Error = ParseModulatorElem(ModulatorList,Scanner,ErrorLine,WaveTableList,
  2132.                     AlgoWaveTableList);
  2133.                 if (Error != eBuildInstrNoError)
  2134.                     {
  2135.                         return Error;
  2136.                     }
  2137.  
  2138.                 /* get semicolon */
  2139.                 Token = GetNextToken(Scanner);
  2140.                 if (Token == NIL)
  2141.                     {
  2142.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2143.                         return eBuildInstrOutOfMemory;
  2144.                     }
  2145.                 if (GetTokenType(Token) != eTokenSemicolon)
  2146.                     {
  2147.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2148.                         return eBuildInstrExpectedSemicolon;
  2149.                     }
  2150.  
  2151.                 return ParseModulatorList(ModulatorList,Scanner,ErrorLine,WaveTableList,
  2152.                     AlgoWaveTableList);
  2153.             }
  2154.  
  2155.         EXECUTE(PRERR(ForceAbort,"ParseModulatorList:  control reached end of function"));
  2156.     }
  2157.  
  2158.  
  2159.  
  2160.  
  2161. /*   45:   <envelope_elem>         ::= totalscaling <number> */
  2162. /*   49:                           ::= points ( <env_point_list> ) */
  2163. /* FIRST SET: */
  2164. /*  <envelope_elem>         : {totalscaling, points} */
  2165. /* FOLLOW SET: */
  2166. /*  <envelope_elem>         : {;} */
  2167. static BuildInstrErrors            ParseEnvelopeElem(EnvelopeRec* Envelope,
  2168.                                                             ScannerRec* Scanner, long *ErrorLine,
  2169.                                                             unsigned long* RequiredDefinitions,
  2170.                                                             unsigned long* OnceOnlyDefinitions)
  2171.     {
  2172.         TokenRec*                                    Token;
  2173.         BuildInstrErrors                    Error;
  2174.         double                                        Number;
  2175.  
  2176.         CheckPtrExistence(Envelope);
  2177.         CheckPtrExistence(Scanner);
  2178.  
  2179.         Token = GetNextToken(Scanner);
  2180.         if (Token == NIL)
  2181.             {
  2182.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2183.                 return eBuildInstrOutOfMemory;
  2184.             }
  2185.         if (GetTokenType(Token) != eTokenKeyword)
  2186.             {
  2187.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2188.                 return eBuildInstrExpectedEnvelopeMember;
  2189.             }
  2190.  
  2191.         switch (GetTokenKeywordTag(Token))
  2192.             {
  2193.                 default:
  2194.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  2195.                     return eBuildInstrExpectedEnvelopeMember;
  2196.  
  2197.                 case eKeywordTotalscaling:
  2198.                     if ((*OnceOnlyDefinitions & ENVELOPEDEFINITION_ONCEONLY_TOTALSCALING) != 0)
  2199.                         {
  2200.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2201.                             return eBuildInstrMultipleEnvTotalScaling;
  2202.                         }
  2203.  
  2204.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  2205.                     if (Error != eBuildInstrNoError)
  2206.                         {
  2207.                             return Error;
  2208.                         }
  2209.                     EnvelopeSetOverallAmplitude(Envelope,Number);
  2210.  
  2211.                     *OnceOnlyDefinitions |= ENVELOPEDEFINITION_ONCEONLY_TOTALSCALING;
  2212.                     break;
  2213.  
  2214.                 case eKeywordPoints:
  2215.                     if ((*OnceOnlyDefinitions & ENVELOPEDEFINITION_ONCEONLY_POINTS) != 0)
  2216.                         {
  2217.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2218.                             return eBuildInstrMultipleEnvPoints;
  2219.                         }
  2220.  
  2221.                     /* open paren */
  2222.                     Token = GetNextToken(Scanner);
  2223.                     if (Token == NIL)
  2224.                         {
  2225.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2226.                             return eBuildInstrOutOfMemory;
  2227.                         }
  2228.                     if (GetTokenType(Token) != eTokenOpenParen)
  2229.                         {
  2230.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2231.                             return eBuildInstrExpectedOpenParen;
  2232.                         }
  2233.  
  2234.                     Error = ParseEnvPointList(Envelope,Scanner,ErrorLine);
  2235.                     if (Error != eBuildInstrNoError)
  2236.                         {
  2237.                             return Error;
  2238.                         }
  2239.  
  2240.                     /* close paren */
  2241.                     Token = GetNextToken(Scanner);
  2242.                     if (Token == NIL)
  2243.                         {
  2244.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2245.                             return eBuildInstrOutOfMemory;
  2246.                         }
  2247.                     if (GetTokenType(Token) != eTokenCloseParen)
  2248.                         {
  2249.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2250.                             return eBuildInstrExpectedCloseParen;
  2251.                         }
  2252.  
  2253.                     *OnceOnlyDefinitions |= ENVELOPEDEFINITION_ONCEONLY_POINTS;
  2254.                     break;
  2255.             }
  2256.  
  2257.         return eBuildInstrNoError;
  2258.     }
  2259.  
  2260.  
  2261.  
  2262.  
  2263. /*   70:   <samplelist_elem>       ::= <identifier> <number> */
  2264. /* FIRST SET: */
  2265. /*  <samplelist_elem>       : {<identifiertoken>, <stringtoken>, <identifier>} */
  2266. /* FOLLOW SET: */
  2267. /*  <samplelist_elem>       : {;} */
  2268. static BuildInstrErrors            ParseSamplelistElem(SampleSelectorRec* SampleList,
  2269.                                                             ScannerRec* Scanner, long* ErrorLine)
  2270.     {
  2271.         BuildInstrErrors                    Error;
  2272.         char*                                            SampleName;
  2273.         double                                        Number;
  2274.  
  2275.         CheckPtrExistence(SampleList);
  2276.         CheckPtrExistence(Scanner);
  2277.  
  2278.         Error = ParseIdentifier(Scanner,ErrorLine,&SampleName);
  2279.         if (Error != eBuildInstrNoError)
  2280.             {
  2281.                 return Error;
  2282.             }
  2283.  
  2284.         Error = ParseNumber(Scanner,ErrorLine,&Number);
  2285.         if (Error != eBuildInstrNoError)
  2286.             {
  2287.                 ReleasePtr(SampleName);
  2288.                 return Error;
  2289.             }
  2290.  
  2291.         if (!AppendSampleSelector(SampleList,Number,SampleName))
  2292.             {
  2293.                 ReleasePtr(SampleName);
  2294.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2295.                 return eBuildInstrOutOfMemory;
  2296.             }
  2297.  
  2298.         return eBuildInstrNoError;
  2299.     }
  2300.  
  2301.  
  2302.  
  2303.  
  2304. /*   73:   <modulator_elem>        ::= source <identifier> scale <modulation_dynamic> */
  2305. /*       originadjust <modulation_dynamic> type <modulator_types> target <target_type> */
  2306. /* FIRST SET: */
  2307. /*  <modulator_elem>        : {source} */
  2308. /* FOLLOW SET: */
  2309. /*  <modulator_elem>        : {;} */
  2310. static BuildInstrErrors            ParseModulatorElem(ModulationSpecRec* ModulatorList,
  2311.                                                             ScannerRec* Scanner, long* ErrorLine,
  2312.                                                             struct WaveTableListRec* WaveTableList,
  2313.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  2314.     {
  2315.         TokenRec*                                    Token;
  2316.         BuildInstrErrors                    Error;
  2317.         char*                                            SourceOscillatorName;
  2318.         EnvelopeRec*                            ScalingFactorEnvelope;
  2319.         LFOListSpecRec*                        ScalingFactorLFOList;
  2320.         EnvelopeRec*                            OriginAdjustEnvelope;
  2321.         LFOListSpecRec*                        OriginAdjustLFOList;
  2322.         ModulationTypes                        Modulation;
  2323.         ModDestTypes                            Destination;
  2324.  
  2325.         CheckPtrExistence(ModulatorList);
  2326.         CheckPtrExistence(Scanner);
  2327.  
  2328.         Token = GetNextToken(Scanner);
  2329.         if (Token == NIL)
  2330.             {
  2331.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2332.                 Error = eBuildInstrOutOfMemory;
  2333.              FailurePoint1:
  2334.                 return Error;
  2335.             }
  2336.         if ((GetTokenType(Token) != eTokenKeyword)
  2337.             || (GetTokenKeywordTag(Token) != eKeywordSource))
  2338.             {
  2339.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2340.                 Error = eBuildInstrExpectedSource;
  2341.              FailurePoint2:
  2342.                 goto FailurePoint1;
  2343.             }
  2344.  
  2345.         Error = ParseIdentifier(Scanner,ErrorLine,&SourceOscillatorName);
  2346.         if (Error != eBuildInstrNoError)
  2347.             {
  2348.              FailurePoint3:
  2349.                 goto FailurePoint2;
  2350.             }
  2351.  
  2352.         Token = GetNextToken(Scanner);
  2353.         if (Token == NIL)
  2354.             {
  2355.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2356.                 Error = eBuildInstrOutOfMemory;
  2357.              FailurePoint4:
  2358.                 ReleasePtr(SourceOscillatorName);
  2359.                 goto FailurePoint3;
  2360.             }
  2361.         if ((GetTokenType(Token) != eTokenKeyword)
  2362.             || (GetTokenKeywordTag(Token) != eKeywordScale))
  2363.             {
  2364.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2365.                 Error = eBuildInstrExpectedScale;
  2366.              FailurePoint5:
  2367.                 goto FailurePoint4;
  2368.             }
  2369.  
  2370.         Error = ParseModulationDynamic(&ScalingFactorLFOList,&ScalingFactorEnvelope,
  2371.             Scanner,ErrorLine,WaveTableList,AlgoWaveTableList);
  2372.         if (Error != eBuildInstrNoError)
  2373.             {
  2374.              FailurePoint6:
  2375.                 goto FailurePoint5;
  2376.             }
  2377.  
  2378.         Token = GetNextToken(Scanner);
  2379.         if (Token == NIL)
  2380.             {
  2381.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2382.                 Error = eBuildInstrOutOfMemory;
  2383.              FailurePoint7:
  2384.                 DisposeEnvelope(ScalingFactorEnvelope);
  2385.                 DisposeLFOListSpecifier(ScalingFactorLFOList);
  2386.                 goto FailurePoint6;
  2387.             }
  2388.         if ((GetTokenType(Token) != eTokenKeyword)
  2389.             || (GetTokenKeywordTag(Token) != eKeywordOriginadjust))
  2390.             {
  2391.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2392.                 Error = eBuildInstrExpectedOriginadjust;
  2393.              FailurePoint8:
  2394.                 goto FailurePoint7;
  2395.             }
  2396.  
  2397.         Error = ParseModulationDynamic(&OriginAdjustLFOList,&OriginAdjustEnvelope,
  2398.             Scanner,ErrorLine,WaveTableList,AlgoWaveTableList);
  2399.         if (Error != eBuildInstrNoError)
  2400.             {
  2401.              FailurePoint9:
  2402.                 goto FailurePoint8;
  2403.             }
  2404.  
  2405.         Token = GetNextToken(Scanner);
  2406.         if (Token == NIL)
  2407.             {
  2408.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2409.                 Error = eBuildInstrOutOfMemory;
  2410.              FailurePoint10:
  2411.                 DisposeEnvelope(OriginAdjustEnvelope);
  2412.                 DisposeLFOListSpecifier(OriginAdjustLFOList);
  2413.                 goto FailurePoint9;
  2414.             }
  2415.         if ((GetTokenType(Token) != eTokenKeyword)
  2416.             || (GetTokenKeywordTag(Token) != eKeywordType))
  2417.             {
  2418.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2419.                 Error = eBuildInstrExpectedType;
  2420.              FailurePoint11:
  2421.                 goto FailurePoint10;
  2422.             }
  2423.  
  2424.         /*  74:   <modulator_types>       ::= additive */
  2425.         /*  75:                           ::= multiplicative */
  2426.         /*  XX:                           ::= inversemult */
  2427.         Token = GetNextToken(Scanner);
  2428.         if (Token == NIL)
  2429.             {
  2430.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2431.                 Error = eBuildInstrOutOfMemory;
  2432.              FailurePoint12:
  2433.                 goto FailurePoint11;
  2434.             }
  2435.         if (GetTokenType(Token) != eTokenKeyword)
  2436.             {
  2437.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2438.                 Error = eBuildInstrExpectedModulationTypeSpecifier;
  2439.              FailurePoint13:
  2440.                 goto FailurePoint12;
  2441.             }
  2442.         switch (GetTokenKeywordTag(Token))
  2443.             {
  2444.                 default:
  2445.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  2446.                     Error = eBuildInstrExpectedModulationTypeSpecifier;
  2447.                  FailurePoint14:
  2448.                     goto FailurePoint13;
  2449.                 case eKeywordAdditive:
  2450.                     Modulation = eModulationAdditive;
  2451.                     break;
  2452.                 case eKeywordMultiplicative:
  2453.                     Modulation = eModulationMultiplicative;
  2454.                     break;
  2455.             }
  2456.  
  2457.         Token = GetNextToken(Scanner);
  2458.         if (Token == NIL)
  2459.             {
  2460.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2461.                 Error = eBuildInstrOutOfMemory;
  2462.              FailurePoint15:
  2463.                 goto FailurePoint14;
  2464.             }
  2465.         if ((GetTokenType(Token) != eTokenKeyword)
  2466.             || (GetTokenKeywordTag(Token) != eKeywordTarget))
  2467.             {
  2468.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2469.                 Error = eBuildInstrExpectedTarget;
  2470.              FailurePoint16:
  2471.                 goto FailurePoint15;
  2472.             }
  2473.  
  2474.         /*  76:   <target_type>           ::= phasegen */
  2475.         /*  77:                           ::= output */
  2476.         Token = GetNextToken(Scanner);
  2477.         if (Token == NIL)
  2478.             {
  2479.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2480.                 Error = eBuildInstrOutOfMemory;
  2481.              FailurePoint17:
  2482.                 goto FailurePoint16;
  2483.             }
  2484.         if (GetTokenType(Token) != eTokenKeyword)
  2485.             {
  2486.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2487.                 Error = eBuildInstrExpectedModulationTargetSpecifier;
  2488.              FailurePoint18:
  2489.                 goto FailurePoint17;
  2490.             }
  2491.         switch (GetTokenKeywordTag(Token))
  2492.             {
  2493.                 default:
  2494.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  2495.                     Error = eBuildInstrExpectedModulationTargetSpecifier;
  2496.                  FailurePoint19:
  2497.                     goto FailurePoint18;
  2498.                 case eKeywordPhasegen:
  2499.                     Destination = eModulatePhaseGen;
  2500.                     break;
  2501.                 case eKeywordOutput:
  2502.                     Destination = eModulateOutput;
  2503.                     break;
  2504.             }
  2505.  
  2506.         if (!AppendModulationSpecEntry(ModulatorList,Modulation,Destination,
  2507.             ScalingFactorEnvelope,ScalingFactorLFOList,OriginAdjustEnvelope,
  2508.             OriginAdjustLFOList,SourceOscillatorName))
  2509.             {
  2510.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2511.                 Error = eBuildInstrOutOfMemory;
  2512.              FailurePoint20:
  2513.                 goto FailurePoint19;
  2514.             }
  2515.  
  2516.         return eBuildInstrNoError;
  2517.     }
  2518.  
  2519.  
  2520.  
  2521.  
  2522. /*   50:   <env_point_list>        ::= <env_point_elem> ; <env_point_list> */
  2523. /*   51:                           ::=  */
  2524. /* FIRST SET: */
  2525. /*  <env_point_list>        : {<integertoken>, <floattoken>, <number>, */
  2526. /*       <env_point_elem>} */
  2527. /* FOLLOW SET: */
  2528. /*  <env_point_list>        : {)} */
  2529. static BuildInstrErrors            ParseEnvPointList(EnvelopeRec* Envelope,
  2530.                                                             ScannerRec* Scanner, long *ErrorLine)
  2531.     {
  2532.         TokenRec*                                    Token;
  2533.         BuildInstrErrors                    Error;
  2534.  
  2535.         CheckPtrExistence(Envelope);
  2536.         CheckPtrExistence(Scanner);
  2537.  
  2538.         Token = GetNextToken(Scanner);
  2539.         if (Token == NIL)
  2540.             {
  2541.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2542.                 return eBuildInstrOutOfMemory;
  2543.             }
  2544.  
  2545.         if (GetTokenType(Token) == eTokenCloseParen)
  2546.             {
  2547.                 UngetToken(Scanner,Token);
  2548.                 return eBuildInstrNoError;
  2549.             }
  2550.          else
  2551.             {
  2552.                 UngetToken(Scanner,Token);
  2553.  
  2554.                 Error = ParseEnvPointElem(Envelope,Scanner,ErrorLine);
  2555.                 if (Error != eBuildInstrNoError)
  2556.                     {
  2557.                         return Error;
  2558.                     }
  2559.  
  2560.                 /* get semicolon */
  2561.                 Token = GetNextToken(Scanner);
  2562.                 if (Token == NIL)
  2563.                     {
  2564.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2565.                         return eBuildInstrOutOfMemory;
  2566.                     }
  2567.                 if (GetTokenType(Token) != eTokenSemicolon)
  2568.                     {
  2569.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2570.                         return eBuildInstrExpectedSemicolon;
  2571.                     }
  2572.  
  2573.                 return ParseEnvPointList(Envelope,Scanner,ErrorLine);
  2574.             }
  2575.  
  2576.         EXECUTE(PRERR(ForceAbort,"ParseEnvPointList:  control reached end of function"));
  2577.     }
  2578.  
  2579.  
  2580.  
  2581.  
  2582. /*   52:   <env_point_elem>        ::= delay <number> level <number> <env_attributes> */
  2583. /*   XX:                           ::= origin */
  2584. /* FIRST SET: */
  2585. /*  <env_point_elem>        : {delay} */
  2586. /* FOLLOW SET: */
  2587. /*  <env_point_elem>        : {<integertoken>, <floattoken>, ), <number>, */
  2588. /*       <env_point_list>, <env_point_elem>} */
  2589. static BuildInstrErrors            ParseEnvPointElem(EnvelopeRec* Envelope,
  2590.                                                             ScannerRec* Scanner, long *ErrorLine)
  2591.     {
  2592.         TokenRec*                                    Token;
  2593.         BuildInstrErrors                    Error;
  2594.         double                                        Delay;
  2595.         double                                        Level;
  2596.  
  2597.         CheckPtrExistence(Envelope);
  2598.         CheckPtrExistence(Scanner);
  2599.  
  2600.         Token = GetNextToken(Scanner);
  2601.         if (Token == NIL)
  2602.             {
  2603.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2604.                 return eBuildInstrOutOfMemory;
  2605.             }
  2606.         if (GetTokenType(Token) != eTokenKeyword)
  2607.             {
  2608.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2609.                 return eBuildInstrExpectedDelayOrOrigin;
  2610.             }
  2611.  
  2612.         switch (GetTokenKeywordTag(Token))
  2613.             {
  2614.                 default:
  2615.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  2616.                     return eBuildInstrExpectedDelayOrOrigin;
  2617.  
  2618.                 case eKeywordDelay:
  2619.                     Error = ParseNumber(Scanner,ErrorLine,&Delay);
  2620.                     if (Error != eBuildInstrNoError)
  2621.                         {
  2622.                             return Error;
  2623.                         }
  2624.  
  2625.                     Token = GetNextToken(Scanner);
  2626.                     if (Token == NIL)
  2627.                         {
  2628.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2629.                             return eBuildInstrOutOfMemory;
  2630.                         }
  2631.                     if ((GetTokenType(Token) != eTokenKeyword)
  2632.                         || ((GetTokenKeywordTag(Token) != eKeywordLevel)
  2633.                             && (GetTokenKeywordTag(Token) != eKeywordScale)))
  2634.                         {
  2635.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2636.                             return eBuildInstrExpectedLevelOrScale;
  2637.                         }
  2638.  
  2639.                     Error = ParseNumber(Scanner,ErrorLine,&Level);
  2640.                     if (Error != eBuildInstrNoError)
  2641.                         {
  2642.                             return Error;
  2643.                         }
  2644.  
  2645.                     if (!EnvelopeInsertPhase(Envelope,GetEnvelopeNumFrames(Envelope)))
  2646.                         {
  2647.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2648.                             return eBuildInstrOutOfMemory;
  2649.                         }
  2650.                     if (GetTokenKeywordTag(Token) == eKeywordScale)
  2651.                         {
  2652.                             EnvelopeSetPhaseTargetType(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2653.                                 eEnvelopeTargetScaling);
  2654.                         }
  2655.                      else
  2656.                         {
  2657.                             EnvelopeSetPhaseTargetType(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2658.                                 eEnvelopeTargetAbsolute);
  2659.                         }
  2660.                     EnvelopeSetPhaseDuration(Envelope,GetEnvelopeNumFrames(Envelope) - 1,Delay);
  2661.                     EnvelopeSetPhaseFinalValue(Envelope,GetEnvelopeNumFrames(Envelope) - 1,Level);
  2662.  
  2663.                     return ParseEnvAttributes(Envelope,Scanner,ErrorLine,0);
  2664.  
  2665.                 case eKeywordOrigin:
  2666.                     EnvelopeSetOrigin(Envelope,GetEnvelopeNumFrames(Envelope));
  2667.                     return eBuildInstrNoError;
  2668.             }
  2669.         EXECUTE(PRERR(ForceAbort,"ParseEnvPointElem:  Control reached end of function"));
  2670.     }
  2671.  
  2672.  
  2673.  
  2674.  
  2675. /*   50:   <env_attributes>        ::= <env_one_attribute> <env_attributes> */
  2676. /*   51:                           ::=  */
  2677. /* FIRST SET: */
  2678. /*  <env_attributes>        : {exponential, linear, sustainpoint, */
  2679. /*       ampaccent1, ampaccent2, ampaccent3, ampaccent4, ampfreq, rateaccent1, */
  2680. /*       rateaccent2, rateaccent3, rateaccent4, ratefreq, <env_one_attribute>} */
  2681. /* FOLLOW SET: */
  2682. /*  <env_attributes>        : {;} */
  2683. static BuildInstrErrors            ParseEnvAttributes(EnvelopeRec* Envelope,
  2684.                                                             ScannerRec* Scanner, long *ErrorLine,
  2685.                                                             unsigned long OnceOnly)
  2686.     {
  2687.         TokenRec*                                    Token;
  2688.         BuildInstrErrors                    Error;
  2689.  
  2690.         CheckPtrExistence(Envelope);
  2691.         CheckPtrExistence(Scanner);
  2692.  
  2693.         Token = GetNextToken(Scanner);
  2694.         if (Token == NIL)
  2695.             {
  2696.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2697.                 return eBuildInstrOutOfMemory;
  2698.             }
  2699.  
  2700.         if (GetTokenType(Token) == eTokenSemicolon)
  2701.             {
  2702.                 UngetToken(Scanner,Token);
  2703.                 return eBuildInstrNoError;
  2704.             }
  2705.          else
  2706.             {
  2707.                 UngetToken(Scanner,Token);
  2708.  
  2709.                 Error = ParseEnvOneAttribute(Envelope,Scanner,ErrorLine,&OnceOnly);
  2710.                 if (Error != eBuildInstrNoError)
  2711.                     {
  2712.                         return Error;
  2713.                     }
  2714.  
  2715.                 return ParseEnvAttributes(Envelope,Scanner,ErrorLine,OnceOnly);
  2716.             }
  2717.  
  2718.         EXECUTE(PRERR(ForceAbort,"ParseEnvAttributes:  control reached end of function"));
  2719.     }
  2720.  
  2721.  
  2722.  
  2723.  
  2724. /*   52:   <env_one_attribute>     ::= sustainpoint <integertoken> */
  2725. /*   53:                           ::= ampaccent1 <number> */
  2726. /*   54:                           ::= ampaccent2 <number> */
  2727. /*   55:                           ::= ampaccent3 <number> */
  2728. /*   56:                           ::= ampaccent4 <number> */
  2729. /*   57:                           ::= ampfreq <number> <number> */
  2730. /*   58:                           ::= rateaccent1 <number> */
  2731. /*   59:                           ::= rateaccent2 <number> */
  2732. /*   60:                           ::= rateaccent3 <number> */
  2733. /*   61:                           ::= rateaccent4 <number> */
  2734. /*   62:                           ::= ratefreq <number> <number> */
  2735. /*   63:                           ::= exponential */
  2736. /*   64:                           ::= linear */
  2737. /* FIRST SET: */
  2738. /*  <env_one_attribute>     : {exponential, linear, sustainpoint, */
  2739. /*       ampaccent1, ampaccent2, ampaccent3, ampaccent4, ampfreq, */
  2740. /*       rateaccent1, rateaccent2, rateaccent3, rateaccent4, ratefreq} */
  2741. /* FOLLOW SET: */
  2742. /*  <env_one_attribute>     : {;, exponential, linear, */
  2743. /*       sustainpoint, ampaccent1, ampaccent2, ampaccent3, ampaccent4, */
  2744. /*       ampfreq, rateaccent1, rateaccent2, rateaccent3, rateaccent4, */
  2745. /*       ratefreq, <env_attributes>, <env_one_attribute>} */
  2746. static BuildInstrErrors            ParseEnvOneAttribute(EnvelopeRec* Envelope,
  2747.                                                             ScannerRec* Scanner, long *ErrorLine,
  2748.                                                             unsigned long* OnceOnlyDefinitions)
  2749.     {
  2750.         TokenRec*                                    Token;
  2751.         BuildInstrErrors                    Error;
  2752.         double                                        Number;
  2753.  
  2754.         CheckPtrExistence(Envelope);
  2755.         CheckPtrExistence(Scanner);
  2756.  
  2757.         Token = GetNextToken(Scanner);
  2758.         if (Token == NIL)
  2759.             {
  2760.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2761.                 return eBuildInstrNoError;
  2762.             }
  2763.         if (GetTokenType(Token) != eTokenKeyword)
  2764.             {
  2765.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2766.                 return eBuildInstrExpectedEnvPointMember;
  2767.             }
  2768.  
  2769.         switch (GetTokenKeywordTag(Token))
  2770.             {
  2771.                 default:
  2772.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  2773.                     return eBuildInstrExpectedEnvPointMember;
  2774.  
  2775.                 case eKeywordSustainpoint:
  2776.                     Token = GetNextToken(Scanner);
  2777.                     if (Token == NIL)
  2778.                         {
  2779.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2780.                             return eBuildInstrNoError;
  2781.                         }
  2782.                     if (GetTokenType(Token) != eTokenInteger)
  2783.                         {
  2784.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2785.                             return eBuildInstrExpectedInteger;
  2786.                         }
  2787.                     switch (GetTokenIntegerValue(Token))
  2788.                         {
  2789.                             default:
  2790.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2791.                                 return eBuildInstrExpectedIntBetween1And3;
  2792.                             case 1:
  2793.                                 if (GetEnvelopeReleasePoint1(Envelope) != -1)
  2794.                                     {
  2795.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2796.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2797.                                     }
  2798.                                 EnvelopeSetReleasePoint1(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2799.                                     eEnvelopeSustainPointSkip);
  2800.                                 break;
  2801.                             case 2:
  2802.                                 if (GetEnvelopeReleasePoint2(Envelope) != -1)
  2803.                                     {
  2804.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2805.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2806.                                     }
  2807.                                 EnvelopeSetReleasePoint2(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2808.                                     eEnvelopeSustainPointSkip);
  2809.                                 break;
  2810.                             case 3:
  2811.                                 if (GetEnvelopeReleasePoint3(Envelope) != -1)
  2812.                                     {
  2813.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2814.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2815.                                     }
  2816.                                 EnvelopeSetReleasePoint3(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2817.                                     eEnvelopeSustainPointSkip);
  2818.                                 break;
  2819.                         }
  2820.                     break;
  2821.  
  2822.                 case eKeywordReleasepoint:
  2823.                     Token = GetNextToken(Scanner);
  2824.                     if (Token == NIL)
  2825.                         {
  2826.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2827.                             return eBuildInstrNoError;
  2828.                         }
  2829.                     if (GetTokenType(Token) != eTokenInteger)
  2830.                         {
  2831.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2832.                             return eBuildInstrExpectedInteger;
  2833.                         }
  2834.                     switch (GetTokenIntegerValue(Token))
  2835.                         {
  2836.                             default:
  2837.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2838.                                 return eBuildInstrExpectedIntBetween1And3;
  2839.                             case 1:
  2840.                                 if (GetEnvelopeReleasePoint1(Envelope) != -1)
  2841.                                     {
  2842.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2843.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2844.                                     }
  2845.                                 EnvelopeSetReleasePoint1(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2846.                                     eEnvelopeReleasePointSkip);
  2847.                                 break;
  2848.                             case 2:
  2849.                                 if (GetEnvelopeReleasePoint2(Envelope) != -1)
  2850.                                     {
  2851.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2852.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2853.                                     }
  2854.                                 EnvelopeSetReleasePoint2(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2855.                                     eEnvelopeReleasePointSkip);
  2856.                                 break;
  2857.                             case 3:
  2858.                                 if (GetEnvelopeReleasePoint3(Envelope) != -1)
  2859.                                     {
  2860.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2861.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2862.                                     }
  2863.                                 EnvelopeSetReleasePoint3(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2864.                                     eEnvelopeReleasePointSkip);
  2865.                                 break;
  2866.                         }
  2867.                     break;
  2868.  
  2869.                 case eKeywordSustainpointnoskip:
  2870.                     Token = GetNextToken(Scanner);
  2871.                     if (Token == NIL)
  2872.                         {
  2873.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2874.                             return eBuildInstrNoError;
  2875.                         }
  2876.                     if (GetTokenType(Token) != eTokenInteger)
  2877.                         {
  2878.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2879.                             return eBuildInstrExpectedInteger;
  2880.                         }
  2881.                     switch (GetTokenIntegerValue(Token))
  2882.                         {
  2883.                             default:
  2884.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2885.                                 return eBuildInstrExpectedIntBetween1And3;
  2886.                             case 1:
  2887.                                 if (GetEnvelopeReleasePoint1(Envelope) != -1)
  2888.                                     {
  2889.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2890.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2891.                                     }
  2892.                                 EnvelopeSetReleasePoint1(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2893.                                     eEnvelopeSustainPointNoSkip);
  2894.                                 break;
  2895.                             case 2:
  2896.                                 if (GetEnvelopeReleasePoint2(Envelope) != -1)
  2897.                                     {
  2898.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2899.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2900.                                     }
  2901.                                 EnvelopeSetReleasePoint2(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2902.                                     eEnvelopeSustainPointNoSkip);
  2903.                                 break;
  2904.                             case 3:
  2905.                                 if (GetEnvelopeReleasePoint3(Envelope) != -1)
  2906.                                     {
  2907.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2908.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2909.                                     }
  2910.                                 EnvelopeSetReleasePoint3(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2911.                                     eEnvelopeSustainPointNoSkip);
  2912.                                 break;
  2913.                         }
  2914.                     break;
  2915.  
  2916.                 case eKeywordReleasepointnoskip:
  2917.                     Token = GetNextToken(Scanner);
  2918.                     if (Token == NIL)
  2919.                         {
  2920.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2921.                             return eBuildInstrNoError;
  2922.                         }
  2923.                     if (GetTokenType(Token) != eTokenInteger)
  2924.                         {
  2925.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2926.                             return eBuildInstrExpectedInteger;
  2927.                         }
  2928.                     switch (GetTokenIntegerValue(Token))
  2929.                         {
  2930.                             default:
  2931.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2932.                                 return eBuildInstrExpectedIntBetween1And3;
  2933.                             case 1:
  2934.                                 if (GetEnvelopeReleasePoint1(Envelope) != -1)
  2935.                                     {
  2936.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2937.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2938.                                     }
  2939.                                 EnvelopeSetReleasePoint1(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2940.                                     eEnvelopeReleasePointNoSkip);
  2941.                                 break;
  2942.                             case 2:
  2943.                                 if (GetEnvelopeReleasePoint2(Envelope) != -1)
  2944.                                     {
  2945.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2946.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2947.                                     }
  2948.                                 EnvelopeSetReleasePoint2(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2949.                                     eEnvelopeReleasePointNoSkip);
  2950.                                 break;
  2951.                             case 3:
  2952.                                 if (GetEnvelopeReleasePoint3(Envelope) != -1)
  2953.                                     {
  2954.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2955.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2956.                                     }
  2957.                                 EnvelopeSetReleasePoint3(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2958.                                     eEnvelopeReleasePointNoSkip);
  2959.                                 break;
  2960.                         }
  2961.                     break;
  2962.  
  2963.                 case eKeywordAmpaccent1:
  2964.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_AMPACCENT1) != 0)
  2965.                         {
  2966.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2967.                             return eBuildInstrMultipleEnvPointAmpAccent1;
  2968.                         }
  2969.  
  2970.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  2971.                     if (Error != eBuildInstrNoError)
  2972.                         {
  2973.                             return Error;
  2974.                         }
  2975.                     EnvelopeSetAccent1Amp(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  2976.  
  2977.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_AMPACCENT1;
  2978.                     break;
  2979.  
  2980.                 case eKeywordAmpaccent2:
  2981.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_AMPACCENT2) != 0)
  2982.                         {
  2983.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2984.                             return eBuildInstrMultipleEnvPointAmpAccent2;
  2985.                         }
  2986.  
  2987.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  2988.                     if (Error != eBuildInstrNoError)
  2989.                         {
  2990.                             return Error;
  2991.                         }
  2992.                     EnvelopeSetAccent2Amp(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  2993.  
  2994.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_AMPACCENT2;
  2995.                     break;
  2996.  
  2997.                 case eKeywordAmpaccent3:
  2998.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_AMPACCENT3) != 0)
  2999.                         {
  3000.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3001.                             return eBuildInstrMultipleEnvPointAmpAccent3;
  3002.                         }
  3003.  
  3004.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3005.                     if (Error != eBuildInstrNoError)
  3006.                         {
  3007.                             return Error;
  3008.                         }
  3009.                     EnvelopeSetAccent3Amp(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3010.  
  3011.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_AMPACCENT3;
  3012.                     break;
  3013.  
  3014.                 case eKeywordAmpaccent4:
  3015.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_AMPACCENT4) != 0)
  3016.                         {
  3017.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3018.                             return eBuildInstrMultipleEnvPointAmpAccent4;
  3019.                         }
  3020.  
  3021.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3022.                     if (Error != eBuildInstrNoError)
  3023.                         {
  3024.                             return Error;
  3025.                         }
  3026.                     EnvelopeSetAccent4Amp(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3027.  
  3028.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_AMPACCENT4;
  3029.                     break;
  3030.  
  3031.                 case eKeywordAmpfreq:
  3032.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_AMPFREQ) != 0)
  3033.                         {
  3034.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3035.                             return eBuildInstrMultipleEnvPointAmpFreq;
  3036.                         }
  3037.  
  3038.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3039.                     if (Error != eBuildInstrNoError)
  3040.                         {
  3041.                             return Error;
  3042.                         }
  3043.                     EnvelopeSetFreqAmpRolloff(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3044.  
  3045.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3046.                     if (Error != eBuildInstrNoError)
  3047.                         {
  3048.                             return Error;
  3049.                         }
  3050.                     EnvelopeSetFreqAmpNormalization(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3051.  
  3052.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_AMPFREQ;
  3053.                     break;
  3054.  
  3055.                 case eKeywordRateaccent1:
  3056.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_RATEACCENT1) != 0)
  3057.                         {
  3058.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3059.                             return eBuildInstrMultipleEnvPointRateAccent1;
  3060.                         }
  3061.  
  3062.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3063.                     if (Error != eBuildInstrNoError)
  3064.                         {
  3065.                             return Error;
  3066.                         }
  3067.                     EnvelopeSetAccent1Rate(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3068.  
  3069.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_RATEACCENT1;
  3070.                     break;
  3071.  
  3072.                 case eKeywordRateaccent2:
  3073.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_RATEACCENT2) != 0)
  3074.                         {
  3075.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3076.                             return eBuildInstrMultipleEnvPointRateAccent2;
  3077.                         }
  3078.  
  3079.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3080.                     if (Error != eBuildInstrNoError)
  3081.                         {
  3082.                             return Error;
  3083.                         }
  3084.                     EnvelopeSetAccent2Rate(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3085.  
  3086.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_RATEACCENT2;
  3087.                     break;
  3088.  
  3089.                 case eKeywordRateaccent3:
  3090.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_RATEACCENT3) != 0)
  3091.                         {
  3092.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3093.                             return eBuildInstrMultipleEnvPointRateAccent3;
  3094.                         }
  3095.  
  3096.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3097.                     if (Error != eBuildInstrNoError)
  3098.                         {
  3099.                             return Error;
  3100.                         }
  3101.                     EnvelopeSetAccent3Rate(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3102.  
  3103.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_RATEACCENT3;
  3104.                     break;
  3105.  
  3106.                 case eKeywordRateaccent4:
  3107.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_RATEACCENT4) != 0)
  3108.                         {
  3109.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3110.                             return eBuildInstrMultipleEnvPointRateAccent4;
  3111.                         }
  3112.  
  3113.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3114.                     if (Error != eBuildInstrNoError)
  3115.                         {
  3116.                             return Error;
  3117.                         }
  3118.                     EnvelopeSetAccent4Rate(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3119.  
  3120.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_RATEACCENT4;
  3121.                     break;
  3122.  
  3123.                 case eKeywordRatefreq:
  3124.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_RATEFREQ) != 0)
  3125.                         {
  3126.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3127.                             return eBuildInstrMultipleEnvPointRateFreq;
  3128.                         }
  3129.  
  3130.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3131.                     if (Error != eBuildInstrNoError)
  3132.                         {
  3133.                             return Error;
  3134.                         }
  3135.                     EnvelopeSetFreqRateRolloff(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3136.  
  3137.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3138.                     if (Error != eBuildInstrNoError)
  3139.                         {
  3140.                             return Error;
  3141.                         }
  3142.                     EnvelopeSetFreqRateNormalization(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3143.  
  3144.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_RATEFREQ;
  3145.                     break;
  3146.  
  3147.                 case eKeywordExponential:
  3148.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_CURVE) != 0)
  3149.                         {
  3150.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3151.                             return eBuildInstrMultipleEnvPointCurveSpec;
  3152.                         }
  3153.  
  3154.                     EnvelopeSetPhaseTransitionType(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  3155.                         eEnvelopeLinearInDecibels);
  3156.  
  3157.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_CURVE;
  3158.                     break;
  3159.  
  3160.                 case eKeywordLinear:
  3161.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_CURVE) != 0)
  3162.                         {
  3163.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3164.                             return eBuildInstrMultipleEnvPointCurveSpec;
  3165.                         }
  3166.  
  3167.                     EnvelopeSetPhaseTransitionType(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  3168.                         eEnvelopeLinearInAmplitude);
  3169.  
  3170.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_CURVE;
  3171.                     break;
  3172.             }
  3173.  
  3174.         return eBuildInstrNoError;
  3175.     }
  3176.  
  3177.  
  3178.  
  3179.  
  3180. /*   XX:   <modulation_dynamic>    ::= envelope ( <envelope_definition> ) */
  3181. /*                                     {lfo ( <lfo> )} */
  3182. /* FOLLOW SET: */
  3183. /*   originadjust, type */
  3184. static BuildInstrErrors            ParseModulationDynamic(LFOListSpecRec** LFOListOut,
  3185.                                                             EnvelopeRec** EnvelopeOut, ScannerRec* Scanner,
  3186.                                                             long* ErrorLine, struct WaveTableListRec* WaveTableList,
  3187.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  3188.     {
  3189.         BuildInstrErrors                    Error;
  3190.         TokenRec*                                    Token;
  3191.         unsigned long                            Required;
  3192.         EnvelopeRec*                            Envelope;
  3193.         LFOListSpecRec*                        LFOList;
  3194.         LFOSpecRec*                                LFO;
  3195.  
  3196.         Envelope = NewEnvelope();
  3197.         if (Envelope == NIL)
  3198.             {
  3199.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3200.                 return eBuildInstrOutOfMemory;
  3201.             }
  3202.         LFOList = NewLFOListSpecifier();
  3203.         if (LFOList == NIL)
  3204.             {
  3205.                 DisposeEnvelope(Envelope);
  3206.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3207.                 return eBuildInstrOutOfMemory;
  3208.             }
  3209.  
  3210.         Token = GetNextToken(Scanner);
  3211.         if (Token == NIL)
  3212.             {
  3213.                 DisposeEnvelope(Envelope);
  3214.                 DisposeLFOListSpecifier(LFOList);
  3215.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3216.                 return eBuildInstrOutOfMemory;
  3217.             }
  3218.         if ((GetTokenType(Token) != eTokenKeyword)
  3219.             || (GetTokenKeywordTag(Token) != eKeywordEnvelope))
  3220.             {
  3221.                 DisposeEnvelope(Envelope);
  3222.                 DisposeLFOListSpecifier(LFOList);
  3223.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3224.                 return eBuildInstrExpectedEnvelope;
  3225.             }
  3226.  
  3227.         Token = GetNextToken(Scanner);
  3228.         if (Token == NIL)
  3229.             {
  3230.                 DisposeEnvelope(Envelope);
  3231.                 DisposeLFOListSpecifier(LFOList);
  3232.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3233.                 return eBuildInstrOutOfMemory;
  3234.             }
  3235.         if (GetTokenType(Token) != eTokenOpenParen)
  3236.             {
  3237.                 DisposeEnvelope(Envelope);
  3238.                 DisposeLFOListSpecifier(LFOList);
  3239.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3240.                 return eBuildInstrExpectedOpenParen;
  3241.             }
  3242.  
  3243.         Required = 0;
  3244.         Error = ParseEnvelopeDefinition(Envelope,Scanner,ErrorLine,&Required,0);
  3245.         if (Error != eBuildInstrNoError)
  3246.             {
  3247.                 DisposeEnvelope(Envelope);
  3248.                 DisposeLFOListSpecifier(LFOList);
  3249.                 return Error;
  3250.             }
  3251.         if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  3252.             {
  3253.                 DisposeEnvelope(Envelope);
  3254.                 DisposeLFOListSpecifier(LFOList);
  3255.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3256.                 return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  3257.             }
  3258.  
  3259.         Token = GetNextToken(Scanner);
  3260.         if (Token == NIL)
  3261.             {
  3262.                 DisposeEnvelope(Envelope);
  3263.                 DisposeLFOListSpecifier(LFOList);
  3264.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3265.                 return eBuildInstrOutOfMemory;
  3266.             }
  3267.         if (GetTokenType(Token) != eTokenCloseParen)
  3268.             {
  3269.                 DisposeEnvelope(Envelope);
  3270.                 DisposeLFOListSpecifier(LFOList);
  3271.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3272.                 return eBuildInstrExpectedCloseParen;
  3273.             }
  3274.  
  3275.         /* we should have used tail recursion, but that's a pain for an ad-hoc addition */
  3276.      LoopPoint:
  3277.  
  3278.         Token = GetNextToken(Scanner);
  3279.         if (Token == NIL)
  3280.             {
  3281.                 DisposeEnvelope(Envelope);
  3282.                 DisposeLFOListSpecifier(LFOList);
  3283.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3284.                 return eBuildInstrOutOfMemory;
  3285.             }
  3286.         if ((GetTokenType(Token) == eTokenKeyword)
  3287.             && ((GetTokenKeywordTag(Token) == eKeywordOriginadjust)
  3288.                 || (GetTokenKeywordTag(Token) == eKeywordType)))
  3289.             {
  3290.                 UngetToken(Scanner,Token);
  3291.                 *EnvelopeOut = Envelope;
  3292.                 *LFOListOut = LFOList;
  3293.                 return eBuildInstrNoError;
  3294.             }
  3295.  
  3296.         if ((GetTokenType(Token) != eTokenKeyword)
  3297.             || (GetTokenKeywordTag(Token) != eKeywordLfo))
  3298.             {
  3299.                 DisposeEnvelope(Envelope);
  3300.                 DisposeLFOListSpecifier(LFOList);
  3301.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3302.                 return eBuildInstrExpectedLFO;
  3303.             }
  3304.  
  3305.         Token = GetNextToken(Scanner);
  3306.         if (Token == NIL)
  3307.             {
  3308.                 DisposeEnvelope(Envelope);
  3309.                 DisposeLFOListSpecifier(LFOList);
  3310.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3311.                 return eBuildInstrOutOfMemory;
  3312.             }
  3313.         if (GetTokenType(Token) != eTokenOpenParen)
  3314.             {
  3315.                 DisposeEnvelope(Envelope);
  3316.                 DisposeLFOListSpecifier(LFOList);
  3317.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3318.                 return eBuildInstrExpectedOpenParen;
  3319.             }
  3320.  
  3321.         LFO = NewLFOSpecifier();
  3322.         if (LFO == NIL)
  3323.             {
  3324.                 DisposeEnvelope(Envelope);
  3325.                 DisposeLFOListSpecifier(LFOList);
  3326.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3327.                 return eBuildInstrOutOfMemory;
  3328.             }
  3329.         Required = 0;
  3330.         Error = ParseLfoDefinition(LFO,Scanner,ErrorLine,&Required,0,WaveTableList,
  3331.             AlgoWaveTableList);
  3332.         if (Error != eBuildInstrNoError)
  3333.             {
  3334.                 DisposeLFOSpecifier(LFO);
  3335.                 DisposeEnvelope(Envelope);
  3336.                 DisposeLFOListSpecifier(LFOList);
  3337.                 return Error;
  3338.             }
  3339.         if (Required != LFODEFINITION_REQUIREDMASK)
  3340.             {
  3341.                 DisposeLFOSpecifier(LFO);
  3342.                 DisposeEnvelope(Envelope);
  3343.                 DisposeLFOListSpecifier(LFOList);
  3344.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3345.                 return eBuildInstrSomeRequiredLFOParamsMissing;
  3346.             }
  3347.         if (!LFOListSpecAppendNewEntry(LFOList,LFO))
  3348.             {
  3349.                 DisposeLFOSpecifier(LFO);
  3350.                 DisposeEnvelope(Envelope);
  3351.                 DisposeLFOListSpecifier(LFOList);
  3352.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3353.                 return eBuildInstrOutOfMemory;
  3354.             }
  3355.  
  3356.         Token = GetNextToken(Scanner);
  3357.         if (Token == NIL)
  3358.             {
  3359.                 DisposeEnvelope(Envelope);
  3360.                 DisposeLFOListSpecifier(LFOList);
  3361.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3362.                 return eBuildInstrOutOfMemory;
  3363.             }
  3364.         if (GetTokenType(Token) != eTokenCloseParen)
  3365.             {
  3366.                 DisposeEnvelope(Envelope);
  3367.                 DisposeLFOListSpecifier(LFOList);
  3368.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3369.                 return eBuildInstrExpectedCloseParen;
  3370.             }
  3371.  
  3372.         goto LoopPoint;
  3373.     }
  3374.  
  3375.  
  3376.  
  3377.  
  3378. /* get a static null terminated string describing the error */
  3379. char*                                                BuildInstrGetErrorMessageText(BuildInstrErrors ErrorCode)
  3380.     {
  3381.         char*                                            S EXECUTE(= (char*)0x81818181);
  3382.  
  3383.         switch (ErrorCode)
  3384.             {
  3385.                 default:
  3386.                     EXECUTE(PRERR(ForceAbort,"BuildInstrGetErrorMessageText:  bad error code"));
  3387.                     break;
  3388.                 case eBuildInstrOutOfMemory:
  3389.                     S = "Out of memory";
  3390.                     break;
  3391.                 case eBuildInstrUnexpectedInput:
  3392.                     S = "Unexpected end of text";
  3393.                     break;
  3394.                 case eBuildInstrExpectedInstrument:
  3395.                     S = "Expected 'instrument'";
  3396.                     break;
  3397.                 case eBuildInstrExpectedOpenParen:
  3398.                     S = "Expected '"OPAREN"'";
  3399.                     break;
  3400.                 case eBuildInstrExpectedCloseParen:
  3401.                     S = "Expected '"CPAREN"'";
  3402.                     break;
  3403.                 case eBuildInstrSomeRequiredInstrParamsMissing:
  3404.                     S = "Some required instrument parameters have not been specified";
  3405.                     break;
  3406.                 case eBuildInstrExpectedSemicolon:
  3407.                     S = "Expected ';'";
  3408.                     break;
  3409.                 case eBuildInstrExpectedInstrumentMember:
  3410.                     S = "Expected 'loudness', 'frequencylfo', or 'oscillator'";
  3411.                     break;
  3412.                 case eBuildInstrMultipleInstrLoudness:
  3413.                     S = "Instrument parameter 'loudness' has already been specified";
  3414.                     break;
  3415.                 case eBuildInstrSomeRequiredLFOParamsMissing:
  3416.                     S = "Some required LFO parameters have not been specified";
  3417.                     break;
  3418.                 case eBuildInstrSomeRequiredOscillatorParamsMissing:
  3419.                     S = "Some required oscillator parameters have not been specified";
  3420.                     break;
  3421.                 case eBuildInstrExpectedNumber:
  3422.                     S = "Expected a number";
  3423.                     break;
  3424.                 case eBuildInstrExpectedStringOrIdentifier:
  3425.                     S = "Expected a string or identifier";
  3426.                     break;
  3427.                 case eBuildInstrExpectedLFOMember:
  3428.                     S = "Expected 'freqenvelope', 'ampenvelope', 'oscillator', 'modulation', "
  3429.                         "'linear', or 'exponential'";
  3430.                     break;
  3431.                 case eBuildInstrMultipleLFOFreqEnvelope:
  3432.                     S = "LFO parameter 'freqenvelope' has already been specified";
  3433.                     break;
  3434.                 case eBuildInstrSomeRequiredEnvelopeParamsMissing:
  3435.                     S = "Some required envelope parameters have not been specified";
  3436.                     break;
  3437.                 case eBuildInstrMultipleLFOAmpEnvelope:
  3438.                     S = "LFO parameter 'ampenvelope' has already been specified";
  3439.                     break;
  3440.                 case eBuildInstrMultipleLFOOscillatorType:
  3441.                     S = "LFO parameter 'oscillator' has already been specified";
  3442.                     break;
  3443.                 case eBuildInstrExpectedLFOOscillatorType:
  3444.                     S = "Expected 'constant', 'signsine', 'plussine', 'signtriangle', "
  3445.                         "'plustriangle', 'signsquare', 'plussquare', 'signramp', 'plusramp', "
  3446.                         "'signlinfuzz', or 'pluslinfuzz'";
  3447.                     break;
  3448.                 case eBuildInstrMultipleLFOModulationType:
  3449.                     S = "LFO parameter 'modulation' has already been specified";
  3450.                     break;
  3451.                 case eBuildInstrMultipleLFOAddingMode:
  3452.                     S = "LFO adding mode ('linear' or 'exponential') has already been specified";
  3453.                     break;
  3454.                 case eBuildInstrExpectedLFOModulationType:
  3455.                     S = "Expected 'additive', 'multiplicative', or 'inversemult'";
  3456.                     break;
  3457.                 case eBuildInstrExpectedOscillatorMember:
  3458.                     S = "Expected 'type', 'samplelist', 'modulators', 'loudness', "
  3459.                         "'freqmultiplier', 'freqdivisor', 'freqadder', 'makeoutput', "
  3460.                         "'loudnessenvelope', 'loudnesslfo', 'indexenvelope', 'indexlfo', "
  3461.                         "'stereobias', or 'displacement'";
  3462.                     break;
  3463.                 case eBuildInstrMultipleOscType:
  3464.                     S = "Oscillator parameter 'type' has already been specified";
  3465.                     break;
  3466.                 case eBuildInstrMultipleOscSampleList:
  3467.                     S = "Oscillator parameter 'samplelist' has already been specified";
  3468.                     break;
  3469.                 case eBuildInstrMultipleOscModulators:
  3470.                     S = "Oscillator parameter 'modulators' has already been specified";
  3471.                     break;
  3472.                 case eBuildInstrMultipleOscLoudness:
  3473.                     S = "Oscillator parameter 'loudness' has already been specified";
  3474.                     break;
  3475.                 case eBuildInstrMultipleOscFreqMultiplier:
  3476.                     S = "Oscillator parameter 'freqmultiplier' has already been specified";
  3477.                     break;
  3478.                 case eBuildInstrMultipleOscFreqDivisor:
  3479.                     S = "Oscillator parameter 'freqdivisor' has already been specified";
  3480.                     break;
  3481.                 case eBuildInstrMultipleOscMakeOutput:
  3482.                     S = "Oscillator parameter 'makeoutput' has already been specified";
  3483.                     break;
  3484.                 case eBuildInstrMultipleOscLoudnessEnvelope:
  3485.                     S = "Oscillator parameter 'loudnessenvelope' has already been specified";
  3486.                     break;
  3487.                 case eBuildInstrMultipleOscIndexEnvelope:
  3488.                     S = "Oscillator parameter 'indexenvelope' has already bee specified";
  3489.                     break;
  3490.                 case eBuildInstrExpectedOscType:
  3491.                     S = "Expected 'sampled' or 'wavetable'";
  3492.                     break;
  3493.                 case eBuildInstrExpectedInteger:
  3494.                     S = "Expected an integer";
  3495.                     break;
  3496.                 case eBuildInstrExpectedBoolean:
  3497.                     S = "Expected 'true' or 'false'";
  3498.                     break;
  3499.                 case eBuildInstrExpectedEnvelopeMember:
  3500.                     S = "Expected 'totalscaling' or 'points'";
  3501.                     break;
  3502.                 case eBuildInstrMultipleEnvTotalScaling:
  3503.                     S = "Envelope parameter 'totalscaling' has already been specified";
  3504.                     break;
  3505.                 case eBuildInstrMultipleEnvPoints:
  3506.                     S = "Envelope parameter 'points' has already been specified";
  3507.                     break;
  3508.                 case eBuildInstrExpectedSource:
  3509.                     S = "Expected 'source'";
  3510.                     break;
  3511.                 case eBuildInstrExpectedScale:
  3512.                     S = "Expected 'scale'";
  3513.                     break;
  3514.                 case eBuildInstrExpectedOriginadjust:
  3515.                     S = "Expected 'originadjust'";
  3516.                     break;
  3517.                 case eBuildInstrExpectedType:
  3518.                     S = "Expected 'type'";
  3519.                     break;
  3520.                 case eBuildInstrExpectedModulationTypeSpecifier:
  3521.                     S = "Expected 'additive' or 'multiplicative'";
  3522.                     break;
  3523.                 case eBuildInstrExpectedTarget:
  3524.                     S = "Expected 'target'";
  3525.                     break;
  3526.                 case eBuildInstrExpectedModulationTargetSpecifier:
  3527.                     S = "Expected 'phasegen' or 'output'";
  3528.                     break;
  3529.                 case eBuildInstrExpectedDelayOrOrigin:
  3530.                     S = "Expected 'delay' or 'origin'";
  3531.                     break;
  3532.                 case eBuildInstrExpectedLevelOrScale:
  3533.                     S = "Expected 'level' or 'scale'";
  3534.                     break;
  3535.                 case eBuildInstrExpectedEnvPointMember:
  3536.                     S = "Expected 'sustainpoint', 'sustainpointnoskip', 'releasepoint', "
  3537.                         "'releasepointnoskip', 'ampaccent1', 'ampaccent2', 'ampaccent3', "
  3538.                         "'ampaccent4', 'ampfreq', 'rateaccent1', 'rateaccent2', 'rateaccent3', "
  3539.                         "'rateaccent4', 'ratefreq', 'exponential', or 'linear'";
  3540.                     break;
  3541.                 case eBuildInstrExpectedIntBetween1And3:
  3542.                     S = "Expected an integer in the range [1..3]";
  3543.                     break;
  3544.                 case eBuildInstrEnvSustainPointAlreadyDefined:
  3545.                     S = "That envelope sustain point has already been specified";
  3546.                     break;
  3547.                 case eBuildInstrMultipleEnvPointAmpAccent1:
  3548.                     S = "Envelope parameter 'ampaccent1' has already been specified";
  3549.                     break;
  3550.                 case eBuildInstrMultipleEnvPointAmpAccent2:
  3551.                     S = "Envelope parameter 'ampaccent2' has already been specified";
  3552.                     break;
  3553.                 case eBuildInstrMultipleEnvPointAmpAccent3:
  3554.                     S = "Envelope parameter 'ampaccent3' has already been specified";
  3555.                     break;
  3556.                 case eBuildInstrMultipleEnvPointAmpAccent4:
  3557.                     S = "Envelope parameter 'ampaccent4' has already been specified";
  3558.                     break;
  3559.                 case eBuildInstrMultipleEnvPointAmpFreq:
  3560.                     S = "Envelope parameter 'ampfreq' has already been specified";
  3561.                     break;
  3562.                 case eBuildInstrMultipleEnvPointRateAccent1:
  3563.                     S = "Envelope parameter 'rateaccent1' has already been specified";
  3564.                     break;
  3565.                 case eBuildInstrMultipleEnvPointRateAccent2:
  3566.                     S = "Envelope parameter 'rateaccent2' has already been specified";
  3567.                     break;
  3568.                 case eBuildInstrMultipleEnvPointRateAccent3:
  3569.                     S = "Envelope parameter 'rateaccent3' has already been specified";
  3570.                     break;
  3571.                 case eBuildInstrMultipleEnvPointRateAccent4:
  3572.                     S = "Envelope parameter 'rateaccent4' has already been specified";
  3573.                     break;
  3574.                 case eBuildInstrMultipleEnvPointRateFreq:
  3575.                     S = "Envelope parameter 'ratefreq' has already been specified";
  3576.                     break;
  3577.                 case eBuildInstrMultipleEnvPointCurveSpec:
  3578.                     S = "Envelope parameter 'exponential' or 'linear' has "
  3579.                         "already been specified";
  3580.                     break;
  3581.                 case eBuildInstrUnresolvedOscillatorReferences:
  3582.                     S = "Some named oscillator references in modulation lists can not be "
  3583.                         "resolved: the named oscillators do not exist";
  3584.                     break;
  3585.                 case eBuildInstrSomeSamplesDontExist:
  3586.                     S = "Some named samples or algorithmic samples do not exist";
  3587.                     break;
  3588.                 case eBuildInstrSomeWaveTablesDontExist:
  3589.                     S = "Some named wave tables or algorithmic wave tables do not exist";
  3590.                     break;
  3591.                 case eBuildInstrExpectedEnvelope:
  3592.                     S = "Expected 'envelope'";
  3593.                     break;
  3594.                 case eBuildInstrExpectedLFO:
  3595.                     S = "Expected 'lfo'";
  3596.                     break;
  3597.                 case eBuildInstrMultipleOscStereoBias:
  3598.                     S = "Oscillator parameter 'stereobias' has already been specified";
  3599.                     break;
  3600.                 case eBuildInstrMultipleOscDisplacement:
  3601.                     S = "Oscillator parameter 'displacement' has already been specified";
  3602.                     break;
  3603.                 case eBuildInstrMultipleOscSurroundBias:
  3604.                     S = "Oscillator parameter 'surroundbias' has already been specified";
  3605.                     break;
  3606.                 case eBuildInserMultipleOscFreqAdder:
  3607.                     S = "Oscillator parameter 'freqadder' has already been specified";
  3608.                     break;
  3609.             }
  3610.  
  3611.         return S;
  3612.     }
  3613.